app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #include <time.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_hexdump.h>
  10 #include <rte_mbuf.h>
  11 #include <rte_malloc.h>
  12 #include <rte_memcpy.h>
  13 #include <rte_pause.h>
  14 #include <rte_bus_vdev.h>
  15 #include <rte_ether.h>
  16
  17 #include <rte_crypto.h>
  18 #include <rte_cryptodev.h>
  19 #include <rte_string_fns.h>
  20
  21 #ifdef RTE_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_LIB_SECURITY
  44 #include "test_cryptodev_security_pdcp_test_vectors.h"
  45 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  46 #include "test_cryptodev_security_pdcp_test_func.h"
  47 #include "test_cryptodev_security_docsis_test_vectors.h"
  48
  49 #define SDAP_DISABLED   0
  50 #define SDAP_ENABLED    1
  51 #endif
  52
  53 #define VDEV_ARGS_SIZE 100
  54 #define MAX_NB_SESSIONS 4
  55
  56 #define MAX_DRV_SERVICE_CTX_SIZE 256
  57
  58 #define MAX_RAW_DEQUEUE_COUNT   65535
  59
  60 #define IN_PLACE 0
  61 #define OUT_OF_PLACE 1
  62
  63 static int gbl_driver_id;
  64
  65 static enum rte_security_session_action_type gbl_action_type =
  66         RTE_SECURITY_ACTION_TYPE_NONE;
  67
  68 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  69
  70 struct crypto_unittest_params {
  71         struct rte_crypto_sym_xform cipher_xform;
  72         struct rte_crypto_sym_xform auth_xform;
  73         struct rte_crypto_sym_xform aead_xform;
  74 #ifdef RTE_LIB_SECURITY
  75         struct rte_security_docsis_xform docsis_xform;
  76 #endif
  77
  78         union {
  79                 struct rte_cryptodev_sym_session *sess;
  80 #ifdef RTE_LIB_SECURITY
  81                 struct rte_security_session *sec_session;
  82 #endif
  83         };
  84 #ifdef RTE_LIB_SECURITY
  85         enum rte_security_session_action_type type;
  86 #endif
  87         struct rte_crypto_op *op;
  88
  89         struct rte_mbuf *obuf, *ibuf;
  90
  91         uint8_t *digest;
  92 };
  93
  94 #define ALIGN_POW2_ROUNDUP(num, align) \
  95         (((num) + (align) - 1) & ~((align) - 1))
  96
  97 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
  98         for (j = 0; j < num_child_ts; index++, j++)                     \
  99                 parent_ts.unit_test_suites[index] = child_ts[j]
 100
 101 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 102         for (j = 0; j < num_blk_types; index++, j++)                            \
 103                 parent_ts.unit_test_suites[index] =                             \
 104                                 build_blockcipher_test_suite(blk_types[j])
 105
 106 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 107         for (j = index; j < index + num_blk_types; j++)                         \
 108                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 109
 110 /*
 111  * Forward declarations.
 112  */
 113 static int
 114 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 115                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 116                 uint8_t *hmac_key);
 117
 118 static int
 119 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 120                 struct crypto_unittest_params *ut_params,
 121                 struct crypto_testsuite_params *ts_param,
 122                 const uint8_t *cipher,
 123                 const uint8_t *digest,
 124                 const uint8_t *iv);
 125
 126 static struct rte_mbuf *
 127 setup_test_string(struct rte_mempool *mpool,
 128                 const char *string, size_t len, uint8_t blocksize)
 129 {
 130         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 131         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 132
 133         if (m) {
 134                 char *dst;
 135
 136                 memset(m->buf_addr, 0, m->buf_len);
 137                 dst = rte_pktmbuf_append(m, t_len);
 138                 if (!dst) {
 139                         rte_pktmbuf_free(m);
 140                         return NULL;
 141                 }
 142                 if (string != NULL)
 143                         rte_memcpy(dst, string, t_len);
 144                 else
 145                         memset(dst, 0, t_len);
 146         }
 147
 148         return m;
 149 }
 150
 151 /* Get number of bytes in X bits (rounding up) */
 152 static uint32_t
 153 ceil_byte_length(uint32_t num_bits)
 154 {
 155         if (num_bits % 8)
 156                 return ((num_bits >> 3) + 1);
 157         else
 158                 return (num_bits >> 3);
 159 }
 160
 161 static void
 162 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 163                 uint8_t is_op_success)
 164 {
 165         struct rte_crypto_op *op = user_data;
 166         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 167                         RTE_CRYPTO_OP_STATUS_ERROR;
 168 }
 169
 170 void
 171 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 172                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 173                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 174 {
 175         struct rte_crypto_sym_op *sop = op->sym;
 176         struct rte_crypto_op *ret_op = NULL;
 177         struct rte_crypto_vec data_vec[UINT8_MAX];
 178         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 179         union rte_crypto_sym_ofs ofs;
 180         struct rte_crypto_sym_vec vec;
 181         struct rte_crypto_sgl sgl;
 182         uint32_t max_len;
 183         union rte_cryptodev_session_ctx sess;
 184         uint32_t count = 0;
 185         struct rte_crypto_raw_dp_ctx *ctx;
 186         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 187                         auth_len = 0;
 188         int32_t n;
 189         uint32_t n_success;
 190         int ctx_service_size;
 191         int32_t status = 0;
 192         int enqueue_status, dequeue_status;
 193
 194         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 195         if (ctx_service_size < 0) {
 196                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 197                 return;
 198         }
 199
 200         ctx = malloc(ctx_service_size);
 201         if (!ctx) {
 202                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 203                 return;
 204         }
 205
 206         /* Both are enums, setting crypto_sess will suit any session type */
 207         sess.crypto_sess = op->sym->session;
 208
 209         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 210                         op->sess_type, sess, 0) < 0) {
 211                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 212                 goto exit;
 213         }
 214
 215         cipher_iv.iova = 0;
 216         cipher_iv.va = NULL;
 217         aad_auth_iv.iova = 0;
 218         aad_auth_iv.va = NULL;
 219         digest.iova = 0;
 220         digest.va = NULL;
 221         sgl.vec = data_vec;
 222         vec.num = 1;
 223         vec.sgl = &sgl;
 224         vec.iv = &cipher_iv;
 225         vec.digest = &digest;
 226         vec.aad = &aad_auth_iv;
 227         vec.status = &status;
 228
 229         ofs.raw = 0;
 230
 231         if (is_cipher && is_auth) {
 232                 cipher_offset = sop->cipher.data.offset;
 233                 cipher_len = sop->cipher.data.length;
 234                 auth_offset = sop->auth.data.offset;
 235                 auth_len = sop->auth.data.length;
 236                 max_len = RTE_MAX(cipher_offset + cipher_len,
 237                                 auth_offset + auth_len);
 238                 if (len_in_bits) {
 239                         max_len = max_len >> 3;
 240                         cipher_offset = cipher_offset >> 3;
 241                         auth_offset = auth_offset >> 3;
 242                         cipher_len = cipher_len >> 3;
 243                         auth_len = auth_len >> 3;
 244                 }
 245                 ofs.ofs.cipher.head = cipher_offset;
 246                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 247                 ofs.ofs.auth.head = auth_offset;
 248                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 249                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 250                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 251                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 252                                 op, void *, IV_OFFSET + cipher_iv_len);
 253                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 254                                 cipher_iv_len);
 255                 digest.va = (void *)sop->auth.digest.data;
 256                 digest.iova = sop->auth.digest.phys_addr;
 257
 258         } else if (is_cipher) {
 259                 cipher_offset = sop->cipher.data.offset;
 260                 cipher_len = sop->cipher.data.length;
 261                 max_len = cipher_len + cipher_offset;
 262                 if (len_in_bits) {
 263                         max_len = max_len >> 3;
 264                         cipher_offset = cipher_offset >> 3;
 265                         cipher_len = cipher_len >> 3;
 266                 }
 267                 ofs.ofs.cipher.head = cipher_offset;
 268                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 269                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 270                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 271
 272         } else if (is_auth) {
 273                 auth_offset = sop->auth.data.offset;
 274                 auth_len = sop->auth.data.length;
 275                 max_len = auth_len + auth_offset;
 276                 if (len_in_bits) {
 277                         max_len = max_len >> 3;
 278                         auth_offset = auth_offset >> 3;
 279                         auth_len = auth_len >> 3;
 280                 }
 281                 ofs.ofs.auth.head = auth_offset;
 282                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 283                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 284                                 op, void *, IV_OFFSET + cipher_iv_len);
 285                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 286                                 cipher_iv_len);
 287                 digest.va = (void *)sop->auth.digest.data;
 288                 digest.iova = sop->auth.digest.phys_addr;
 289
 290         } else { /* aead */
 291                 cipher_offset = sop->aead.data.offset;
 292                 cipher_len = sop->aead.data.length;
 293                 max_len = cipher_len + cipher_offset;
 294                 if (len_in_bits) {
 295                         max_len = max_len >> 3;
 296                         cipher_offset = cipher_offset >> 3;
 297                         cipher_len = cipher_len >> 3;
 298                 }
 299                 ofs.ofs.cipher.head = cipher_offset;
 300                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 301                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 302                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 303                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 304                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 305                 digest.va = (void *)sop->aead.digest.data;
 306                 digest.iova = sop->aead.digest.phys_addr;
 307         }
 308
 309         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 310                         data_vec, RTE_DIM(data_vec));
 311         if (n < 0 || n > sop->m_src->nb_segs) {
 312                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 313                 goto exit;
 314         }
 315
 316         sgl.num = n;
 317
 318         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 319                         &enqueue_status) < 1) {
 320                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 321                 goto exit;
 322         }
 323
 324         if (enqueue_status == 0) {
 325                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 326                 if (status < 0) {
 327                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 328                         goto exit;
 329                 }
 330         } else if (enqueue_status < 0) {
 331                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 332                 goto exit;
 333         }
 334
 335         n = n_success = 0;
 336         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 337                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 338                         NULL, 1, post_process_raw_dp_op,
 339                                 (void **)&ret_op, 0, &n_success,
 340                                 &dequeue_status);
 341                 if (dequeue_status < 0) {
 342                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 343                         goto exit;
 344                 }
 345                 if (n == 0)
 346                         rte_pause();
 347         }
 348
 349         if (n == 1 && dequeue_status == 0) {
 350                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 351                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 352                         goto exit;
 353                 }
 354         }
 355
 356         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 357                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 358                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 359
 360 exit:
 361         free(ctx);
 362 }
 363
 364 static void
 365 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 366 {
 367         int32_t n, st;
 368         struct rte_crypto_sym_op *sop;
 369         union rte_crypto_sym_ofs ofs;
 370         struct rte_crypto_sgl sgl;
 371         struct rte_crypto_sym_vec symvec;
 372         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 373         struct rte_crypto_vec vec[UINT8_MAX];
 374
 375         sop = op->sym;
 376
 377         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 378                 sop->aead.data.length, vec, RTE_DIM(vec));
 379
 380         if (n < 0 || n != sop->m_src->nb_segs) {
 381                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 382                 return;
 383         }
 384
 385         sgl.vec = vec;
 386         sgl.num = n;
 387         symvec.sgl = &sgl;
 388         symvec.iv = &iv_ptr;
 389         symvec.digest = &digest_ptr;
 390         symvec.aad = &aad_ptr;
 391         symvec.status = &st;
 392         symvec.num = 1;
 393
 394         /* for CPU crypto the IOVA address is not required */
 395         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 396         digest_ptr.va = (void *)sop->aead.digest.data;
 397         aad_ptr.va = (void *)sop->aead.aad.data;
 398
 399         ofs.raw = 0;
 400
 401         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 402                 &symvec);
 403
 404         if (n != 1)
 405                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 406         else
 407                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 408 }
 409
 410 static void
 411 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 412 {
 413         int32_t n, st;
 414         struct rte_crypto_sym_op *sop;
 415         union rte_crypto_sym_ofs ofs;
 416         struct rte_crypto_sgl sgl;
 417         struct rte_crypto_sym_vec symvec;
 418         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 419         struct rte_crypto_vec vec[UINT8_MAX];
 420
 421         sop = op->sym;
 422
 423         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 424                 sop->auth.data.length, vec, RTE_DIM(vec));
 425
 426         if (n < 0 || n != sop->m_src->nb_segs) {
 427                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 428                 return;
 429         }
 430
 431         sgl.vec = vec;
 432         sgl.num = n;
 433         symvec.sgl = &sgl;
 434         symvec.iv = &iv_ptr;
 435         symvec.digest = &digest_ptr;
 436         symvec.status = &st;
 437         symvec.num = 1;
 438
 439         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 440         digest_ptr.va = (void *)sop->auth.digest.data;
 441
 442         ofs.raw = 0;
 443         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 444         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 445                 (sop->cipher.data.offset + sop->cipher.data.length);
 446
 447         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 448                 &symvec);
 449
 450         if (n != 1)
 451                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 452         else
 453                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 454 }
 455
 456 static struct rte_crypto_op *
 457 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 458 {
 459
 460         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 461
 462         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 463                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 464                 return NULL;
 465         }
 466
 467         op = NULL;
 468
 469         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 470                 rte_pause();
 471
 472         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 473                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 474                 return NULL;
 475         }
 476
 477         return op;
 478 }
 479
 480 static struct crypto_testsuite_params testsuite_params = { NULL };
 481 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 482 static struct crypto_unittest_params unittest_params;
 483
 484 static int
 485 testsuite_setup(void)
 486 {
 487         struct crypto_testsuite_params *ts_params = &testsuite_params;
 488         struct rte_cryptodev_info info;
 489         uint32_t i = 0, nb_devs, dev_id;
 490         uint16_t qp_id;
 491
 492         memset(ts_params, 0, sizeof(*ts_params));
 493
 494         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 495         if (ts_params->mbuf_pool == NULL) {
 496                 /* Not already created so create */
 497                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 498                                 "CRYPTO_MBUFPOOL",
 499                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 500                                 rte_socket_id());
 501                 if (ts_params->mbuf_pool == NULL) {
 502                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 503                         return TEST_FAILED;
 504                 }
 505         }
 506
 507         ts_params->large_mbuf_pool = rte_mempool_lookup(
 508                         "CRYPTO_LARGE_MBUFPOOL");
 509         if (ts_params->large_mbuf_pool == NULL) {
 510                 /* Not already created so create */
 511                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 512                                 "CRYPTO_LARGE_MBUFPOOL",
 513                                 1, 0, 0, UINT16_MAX,
 514                                 rte_socket_id());
 515                 if (ts_params->large_mbuf_pool == NULL) {
 516                         RTE_LOG(ERR, USER1,
 517                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 518                         return TEST_FAILED;
 519                 }
 520         }
 521
 522         ts_params->op_mpool = rte_crypto_op_pool_create(
 523                         "MBUF_CRYPTO_SYM_OP_POOL",
 524                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 525                         NUM_MBUFS, MBUF_CACHE_SIZE,
 526                         DEFAULT_NUM_XFORMS *
 527                         sizeof(struct rte_crypto_sym_xform) +
 528                         MAXIMUM_IV_LENGTH,
 529                         rte_socket_id());
 530         if (ts_params->op_mpool == NULL) {
 531                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 532                 return TEST_FAILED;
 533         }
 534
 535         nb_devs = rte_cryptodev_count();
 536         if (nb_devs < 1) {
 537                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 538                 return TEST_SKIPPED;
 539         }
 540
 541         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 542                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 543                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 544                 return TEST_SKIPPED;
 545         }
 546
 547         /* Create list of valid crypto devs */
 548         for (i = 0; i < nb_devs; i++) {
 549                 rte_cryptodev_info_get(i, &info);
 550                 if (info.driver_id == gbl_driver_id)
 551                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 552         }
 553
 554         if (ts_params->valid_dev_count < 1)
 555                 return TEST_FAILED;
 556
 557         /* Set up all the qps on the first of the valid devices found */
 558
 559         dev_id = ts_params->valid_devs[0];
 560
 561         rte_cryptodev_info_get(dev_id, &info);
 562
 563         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 564         ts_params->conf.socket_id = SOCKET_ID_ANY;
 565         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 566
 567         unsigned int session_size =
 568                 rte_cryptodev_sym_get_private_session_size(dev_id);
 569
 570 #ifdef RTE_LIB_SECURITY
 571         unsigned int security_session_size = rte_security_session_get_size(
 572                         rte_cryptodev_get_sec_ctx(dev_id));
 573
 574         if (session_size < security_session_size)
 575                 session_size = security_session_size;
 576 #endif
 577         /*
 578          * Create mempool with maximum number of sessions.
 579          */
 580         if (info.sym.max_nb_sessions != 0 &&
 581                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 582                 RTE_LOG(ERR, USER1, "Device does not support "
 583                                 "at least %u sessions\n",
 584                                 MAX_NB_SESSIONS);
 585                 return TEST_FAILED;
 586         }
 587
 588         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 589                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 590                         SOCKET_ID_ANY);
 591         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 592                         "session mempool allocation failed");
 593
 594         ts_params->session_priv_mpool = rte_mempool_create(
 595                         "test_sess_mp_priv",
 596                         MAX_NB_SESSIONS,
 597                         session_size,
 598                         0, 0, NULL, NULL, NULL,
 599                         NULL, SOCKET_ID_ANY,
 600                         0);
 601         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 602                         "session mempool allocation failed");
 603
 604
 605
 606         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 607                         &ts_params->conf),
 608                         "Failed to configure cryptodev %u with %u qps",
 609                         dev_id, ts_params->conf.nb_queue_pairs);
 610
 611         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 612         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 613         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 614
 615         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 616                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 617                         dev_id, qp_id, &ts_params->qp_conf,
 618                         rte_cryptodev_socket_id(dev_id)),
 619                         "Failed to setup queue pair %u on cryptodev %u",
 620                         qp_id, dev_id);
 621         }
 622
 623         return TEST_SUCCESS;
 624 }
 625
 626 static void
 627 testsuite_teardown(void)
 628 {
 629         struct crypto_testsuite_params *ts_params = &testsuite_params;
 630         int res;
 631
 632         if (ts_params->mbuf_pool != NULL) {
 633                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 634                 rte_mempool_avail_count(ts_params->mbuf_pool));
 635         }
 636
 637         if (ts_params->op_mpool != NULL) {
 638                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 639                 rte_mempool_avail_count(ts_params->op_mpool));
 640         }
 641
 642         /* Free session mempools */
 643         if (ts_params->session_priv_mpool != NULL) {
 644                 rte_mempool_free(ts_params->session_priv_mpool);
 645                 ts_params->session_priv_mpool = NULL;
 646         }
 647
 648         if (ts_params->session_mpool != NULL) {
 649                 rte_mempool_free(ts_params->session_mpool);
 650                 ts_params->session_mpool = NULL;
 651         }
 652
 653         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 654         if (res)
 655                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 656 }
 657
 658 static int
 659 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 660                 const int *algs, uint16_t num_algs)
 661 {
 662         uint8_t dev_id = testsuite_params.valid_devs[0];
 663         bool some_alg_supported = FALSE;
 664         uint16_t i;
 665
 666         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 667                 struct rte_cryptodev_sym_capability_idx alg = {
 668                         type, {algs[i]}
 669                 };
 670                 if (rte_cryptodev_sym_capability_get(dev_id,
 671                                 &alg) != NULL)
 672                         some_alg_supported = TRUE;
 673         }
 674         if (!some_alg_supported)
 675                 return TEST_SKIPPED;
 676
 677         return 0;
 678 }
 679
 680 int
 681 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 682                 uint16_t num_ciphers)
 683 {
 684         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 685                         (const int *) ciphers, num_ciphers);
 686 }
 687
 688 int
 689 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 690                 uint16_t num_auths)
 691 {
 692         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 693                         (const int *) auths, num_auths);
 694 }
 695
 696 int
 697 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 698                 uint16_t num_aeads)
 699 {
 700         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 701                         (const int *) aeads, num_aeads);
 702 }
 703
 704 static int
 705 null_testsuite_setup(void)
 706 {
 707         struct crypto_testsuite_params *ts_params = &testsuite_params;
 708         uint8_t dev_id = ts_params->valid_devs[0];
 709         struct rte_cryptodev_info dev_info;
 710         const enum rte_crypto_cipher_algorithm ciphers[] = {
 711                 RTE_CRYPTO_CIPHER_NULL
 712         };
 713         const enum rte_crypto_auth_algorithm auths[] = {
 714                 RTE_CRYPTO_AUTH_NULL
 715         };
 716
 717         rte_cryptodev_info_get(dev_id, &dev_info);
 718
 719         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 720                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 721                                 "testsuite not met\n");
 722                 return TEST_SKIPPED;
 723         }
 724
 725         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 726                         && check_auth_capabilities_supported(auths,
 727                         RTE_DIM(auths)) != 0) {
 728                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 729                                 "testsuite not met\n");
 730                 return TEST_SKIPPED;
 731         }
 732
 733         return 0;
 734 }
 735
 736 static int
 737 crypto_gen_testsuite_setup(void)
 738 {
 739         struct crypto_testsuite_params *ts_params = &testsuite_params;
 740         uint8_t dev_id = ts_params->valid_devs[0];
 741         struct rte_cryptodev_info dev_info;
 742
 743         rte_cryptodev_info_get(dev_id, &dev_info);
 744
 745         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 746                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 747                                 "testsuite not met\n");
 748                 return TEST_SKIPPED;
 749         }
 750
 751         return 0;
 752 }
 753
 754 #ifdef RTE_LIB_SECURITY
 755 static int
 756 pdcp_proto_testsuite_setup(void)
 757 {
 758         struct crypto_testsuite_params *ts_params = &testsuite_params;
 759         uint8_t dev_id = ts_params->valid_devs[0];
 760         struct rte_cryptodev_info dev_info;
 761         const enum rte_crypto_cipher_algorithm ciphers[] = {
 762                 RTE_CRYPTO_CIPHER_NULL,
 763                 RTE_CRYPTO_CIPHER_AES_CTR,
 764                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 765                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 766         };
 767         const enum rte_crypto_auth_algorithm auths[] = {
 768                 RTE_CRYPTO_AUTH_NULL,
 769                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 770                 RTE_CRYPTO_AUTH_AES_CMAC,
 771                 RTE_CRYPTO_AUTH_ZUC_EIA3
 772         };
 773
 774         rte_cryptodev_info_get(dev_id, &dev_info);
 775
 776         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 777                         !(dev_info.feature_flags &
 778                         RTE_CRYPTODEV_FF_SECURITY)) {
 779                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 780                                 "testsuite not met\n");
 781                 return TEST_SKIPPED;
 782         }
 783
 784         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 785                         && check_auth_capabilities_supported(auths,
 786                         RTE_DIM(auths)) != 0) {
 787                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 788                                 "testsuite not met\n");
 789                 return TEST_SKIPPED;
 790         }
 791
 792         return 0;
 793 }
 794
 795 static int
 796 docsis_proto_testsuite_setup(void)
 797 {
 798         struct crypto_testsuite_params *ts_params = &testsuite_params;
 799         uint8_t dev_id = ts_params->valid_devs[0];
 800         struct rte_cryptodev_info dev_info;
 801         const enum rte_crypto_cipher_algorithm ciphers[] = {
 802                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 803         };
 804
 805         rte_cryptodev_info_get(dev_id, &dev_info);
 806
 807         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 808                         !(dev_info.feature_flags &
 809                         RTE_CRYPTODEV_FF_SECURITY)) {
 810                 RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis "
 811                                 "Proto testsuite not met\n");
 812                 return TEST_SKIPPED;
 813         }
 814
 815         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 816                 RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto "
 817                                 "testsuite not met\n");
 818                 return TEST_SKIPPED;
 819         }
 820
 821         return 0;
 822 }
 823 #endif
 824
 825 static int
 826 aes_ccm_auth_testsuite_setup(void)
 827 {
 828         struct crypto_testsuite_params *ts_params = &testsuite_params;
 829         uint8_t dev_id = ts_params->valid_devs[0];
 830         struct rte_cryptodev_info dev_info;
 831         const enum rte_crypto_aead_algorithm aeads[] = {
 832                 RTE_CRYPTO_AEAD_AES_CCM
 833         };
 834
 835         rte_cryptodev_info_get(dev_id, &dev_info);
 836
 837         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 838                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 839                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 840                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 841                                 "testsuite not met\n");
 842                 return TEST_SKIPPED;
 843         }
 844
 845         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 846                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 847                                 "testsuite not met\n");
 848                 return TEST_SKIPPED;
 849         }
 850
 851         return 0;
 852 }
 853
 854 static int
 855 aes_gcm_auth_testsuite_setup(void)
 856 {
 857         struct crypto_testsuite_params *ts_params = &testsuite_params;
 858         uint8_t dev_id = ts_params->valid_devs[0];
 859         struct rte_cryptodev_info dev_info;
 860         const enum rte_crypto_aead_algorithm aeads[] = {
 861                 RTE_CRYPTO_AEAD_AES_GCM
 862         };
 863
 864         rte_cryptodev_info_get(dev_id, &dev_info);
 865
 866         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 867                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 868                                 "testsuite not met\n");
 869                 return TEST_SKIPPED;
 870         }
 871
 872         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 873                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 874                                 "testsuite not met\n");
 875                 return TEST_SKIPPED;
 876         }
 877
 878         return 0;
 879 }
 880
 881 static int
 882 aes_gmac_auth_testsuite_setup(void)
 883 {
 884         struct crypto_testsuite_params *ts_params = &testsuite_params;
 885         uint8_t dev_id = ts_params->valid_devs[0];
 886         struct rte_cryptodev_info dev_info;
 887         const enum rte_crypto_auth_algorithm auths[] = {
 888                 RTE_CRYPTO_AUTH_AES_GMAC
 889         };
 890
 891         rte_cryptodev_info_get(dev_id, &dev_info);
 892
 893         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 894                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 895                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 896                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
 897                                 "testsuite not met\n");
 898                 return TEST_SKIPPED;
 899         }
 900
 901         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
 902                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
 903                                 "testsuite not met\n");
 904                 return TEST_SKIPPED;
 905         }
 906
 907         return 0;
 908 }
 909
 910 static int
 911 chacha20_poly1305_testsuite_setup(void)
 912 {
 913         struct crypto_testsuite_params *ts_params = &testsuite_params;
 914         uint8_t dev_id = ts_params->valid_devs[0];
 915         struct rte_cryptodev_info dev_info;
 916         const enum rte_crypto_aead_algorithm aeads[] = {
 917                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
 918         };
 919
 920         rte_cryptodev_info_get(dev_id, &dev_info);
 921
 922         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 923                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 924                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 925                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
 926                                 "Chacha20-Poly1305 testsuite not met\n");
 927                 return TEST_SKIPPED;
 928         }
 929
 930         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 931                 RTE_LOG(INFO, USER1, "Capability requirements for "
 932                                 "Chacha20-Poly1305 testsuite not met\n");
 933                 return TEST_SKIPPED;
 934         }
 935
 936         return 0;
 937 }
 938
 939 static int
 940 snow3g_testsuite_setup(void)
 941 {
 942         struct crypto_testsuite_params *ts_params = &testsuite_params;
 943         uint8_t dev_id = ts_params->valid_devs[0];
 944         struct rte_cryptodev_info dev_info;
 945         const enum rte_crypto_cipher_algorithm ciphers[] = {
 946                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 947
 948         };
 949         const enum rte_crypto_auth_algorithm auths[] = {
 950                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
 951         };
 952
 953         rte_cryptodev_info_get(dev_id, &dev_info);
 954
 955         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 956                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
 957                                 "testsuite not met\n");
 958                 return TEST_SKIPPED;
 959         }
 960
 961         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 962                         && check_auth_capabilities_supported(auths,
 963                         RTE_DIM(auths)) != 0) {
 964                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
 965                                 "testsuite not met\n");
 966                 return TEST_SKIPPED;
 967         }
 968
 969         return 0;
 970 }
 971
 972 static int
 973 zuc_testsuite_setup(void)
 974 {
 975         struct crypto_testsuite_params *ts_params = &testsuite_params;
 976         uint8_t dev_id = ts_params->valid_devs[0];
 977         struct rte_cryptodev_info dev_info;
 978         const enum rte_crypto_cipher_algorithm ciphers[] = {
 979                 RTE_CRYPTO_CIPHER_ZUC_EEA3
 980         };
 981         const enum rte_crypto_auth_algorithm auths[] = {
 982                 RTE_CRYPTO_AUTH_ZUC_EIA3
 983         };
 984
 985         rte_cryptodev_info_get(dev_id, &dev_info);
 986
 987         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 988                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
 989                                 "testsuite not met\n");
 990                 return TEST_SKIPPED;
 991         }
 992
 993         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 994                         && check_auth_capabilities_supported(auths,
 995                         RTE_DIM(auths)) != 0) {
 996                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
 997                                 "testsuite not met\n");
 998                 return TEST_SKIPPED;
 999         }
1000
1001         return 0;
1002 }
1003
1004 static int
1005 hmac_md5_auth_testsuite_setup(void)
1006 {
1007         struct crypto_testsuite_params *ts_params = &testsuite_params;
1008         uint8_t dev_id = ts_params->valid_devs[0];
1009         struct rte_cryptodev_info dev_info;
1010         const enum rte_crypto_auth_algorithm auths[] = {
1011                 RTE_CRYPTO_AUTH_MD5_HMAC
1012         };
1013
1014         rte_cryptodev_info_get(dev_id, &dev_info);
1015
1016         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1017                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1018                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1019                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1020                                 "Auth testsuite not met\n");
1021                 return TEST_SKIPPED;
1022         }
1023
1024         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1025                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1026                                 "testsuite not met\n");
1027                 return TEST_SKIPPED;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int
1034 kasumi_testsuite_setup(void)
1035 {
1036         struct crypto_testsuite_params *ts_params = &testsuite_params;
1037         uint8_t dev_id = ts_params->valid_devs[0];
1038         struct rte_cryptodev_info dev_info;
1039         const enum rte_crypto_cipher_algorithm ciphers[] = {
1040                 RTE_CRYPTO_CIPHER_KASUMI_F8
1041         };
1042         const enum rte_crypto_auth_algorithm auths[] = {
1043                 RTE_CRYPTO_AUTH_KASUMI_F9
1044         };
1045
1046         rte_cryptodev_info_get(dev_id, &dev_info);
1047
1048         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1049                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1050                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1051                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1052                                 "testsuite not met\n");
1053                 return TEST_SKIPPED;
1054         }
1055
1056         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1057                         && check_auth_capabilities_supported(auths,
1058                         RTE_DIM(auths)) != 0) {
1059                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1060                                 "testsuite not met\n");
1061                 return TEST_SKIPPED;
1062         }
1063
1064         return 0;
1065 }
1066
1067 static int
1068 negative_aes_gcm_testsuite_setup(void)
1069 {
1070         struct crypto_testsuite_params *ts_params = &testsuite_params;
1071         uint8_t dev_id = ts_params->valid_devs[0];
1072         struct rte_cryptodev_info dev_info;
1073         const enum rte_crypto_aead_algorithm aeads[] = {
1074                 RTE_CRYPTO_AEAD_AES_GCM
1075         };
1076
1077         rte_cryptodev_info_get(dev_id, &dev_info);
1078
1079         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1080                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1081                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1082                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1083                                 "AES GCM testsuite not met\n");
1084                 return TEST_SKIPPED;
1085         }
1086
1087         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1088                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1089                                 "AES GCM testsuite not met\n");
1090                 return TEST_SKIPPED;
1091         }
1092
1093         return 0;
1094 }
1095
1096 static int
1097 negative_aes_gmac_testsuite_setup(void)
1098 {
1099         struct crypto_testsuite_params *ts_params = &testsuite_params;
1100         uint8_t dev_id = ts_params->valid_devs[0];
1101         struct rte_cryptodev_info dev_info;
1102         const enum rte_crypto_auth_algorithm auths[] = {
1103                 RTE_CRYPTO_AUTH_AES_GMAC
1104         };
1105
1106         rte_cryptodev_info_get(dev_id, &dev_info);
1107
1108         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1109                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1110                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1111                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1112                                 "AES GMAC testsuite not met\n");
1113                 return TEST_SKIPPED;
1114         }
1115
1116         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1117                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1118                                 "AES GMAC testsuite not met\n");
1119                 return TEST_SKIPPED;
1120         }
1121
1122         return 0;
1123 }
1124
1125 static int
1126 mixed_cipher_hash_testsuite_setup(void)
1127 {
1128         struct crypto_testsuite_params *ts_params = &testsuite_params;
1129         uint8_t dev_id = ts_params->valid_devs[0];
1130         struct rte_cryptodev_info dev_info;
1131         uint64_t feat_flags;
1132         const enum rte_crypto_cipher_algorithm ciphers[] = {
1133                 RTE_CRYPTO_CIPHER_NULL,
1134                 RTE_CRYPTO_CIPHER_AES_CTR,
1135                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1136                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1137         };
1138         const enum rte_crypto_auth_algorithm auths[] = {
1139                 RTE_CRYPTO_AUTH_NULL,
1140                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1141                 RTE_CRYPTO_AUTH_AES_CMAC,
1142                 RTE_CRYPTO_AUTH_ZUC_EIA3
1143         };
1144
1145         rte_cryptodev_info_get(dev_id, &dev_info);
1146         feat_flags = dev_info.feature_flags;
1147
1148         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1149                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1150                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1151                                 "Cipher Hash testsuite not met\n");
1152                 return TEST_SKIPPED;
1153         }
1154
1155         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1156                         && check_auth_capabilities_supported(auths,
1157                         RTE_DIM(auths)) != 0) {
1158                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1159                                 "Cipher Hash testsuite not met\n");
1160                 return TEST_SKIPPED;
1161         }
1162
1163         return 0;
1164 }
1165
1166 static int
1167 esn_testsuite_setup(void)
1168 {
1169         struct crypto_testsuite_params *ts_params = &testsuite_params;
1170         uint8_t dev_id = ts_params->valid_devs[0];
1171         struct rte_cryptodev_info dev_info;
1172         const enum rte_crypto_cipher_algorithm ciphers[] = {
1173                 RTE_CRYPTO_CIPHER_AES_CBC
1174         };
1175         const enum rte_crypto_auth_algorithm auths[] = {
1176                 RTE_CRYPTO_AUTH_SHA1_HMAC
1177         };
1178
1179         rte_cryptodev_info_get(dev_id, &dev_info);
1180
1181         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1182                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1183                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1184                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1185                                 "testsuite not met\n");
1186                 return TEST_SKIPPED;
1187         }
1188
1189         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1190                         && check_auth_capabilities_supported(auths,
1191                         RTE_DIM(auths)) != 0) {
1192                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1193                                 "testsuite not met\n");
1194                 return TEST_SKIPPED;
1195         }
1196
1197         return 0;
1198 }
1199
1200 static int
1201 multi_session_testsuite_setup(void)
1202 {
1203         struct crypto_testsuite_params *ts_params = &testsuite_params;
1204         uint8_t dev_id = ts_params->valid_devs[0];
1205         struct rte_cryptodev_info dev_info;
1206         const enum rte_crypto_cipher_algorithm ciphers[] = {
1207                 RTE_CRYPTO_CIPHER_AES_CBC
1208         };
1209         const enum rte_crypto_auth_algorithm auths[] = {
1210                 RTE_CRYPTO_AUTH_SHA512_HMAC
1211         };
1212
1213         rte_cryptodev_info_get(dev_id, &dev_info);
1214
1215         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1216                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1217                                 "Session testsuite not met\n");
1218                 return TEST_SKIPPED;
1219         }
1220
1221         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1222                         && check_auth_capabilities_supported(auths,
1223                         RTE_DIM(auths)) != 0) {
1224                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1225                                 "Session testsuite not met\n");
1226                 return TEST_SKIPPED;
1227         }
1228
1229         return 0;
1230 }
1231
1232 static int
1233 negative_hmac_sha1_testsuite_setup(void)
1234 {
1235         struct crypto_testsuite_params *ts_params = &testsuite_params;
1236         uint8_t dev_id = ts_params->valid_devs[0];
1237         struct rte_cryptodev_info dev_info;
1238         const enum rte_crypto_cipher_algorithm ciphers[] = {
1239                 RTE_CRYPTO_CIPHER_AES_CBC
1240         };
1241         const enum rte_crypto_auth_algorithm auths[] = {
1242                 RTE_CRYPTO_AUTH_SHA1_HMAC
1243         };
1244
1245         rte_cryptodev_info_get(dev_id, &dev_info);
1246
1247         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1248                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1249                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1250                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1251                                 "HMAC SHA1 testsuite not met\n");
1252                 return TEST_SKIPPED;
1253         }
1254
1255         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1256                         && check_auth_capabilities_supported(auths,
1257                         RTE_DIM(auths)) != 0) {
1258                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1259                                 "HMAC SHA1 testsuite not met\n");
1260                 return TEST_SKIPPED;
1261         }
1262
1263         return 0;
1264 }
1265
1266 static int
1267 dev_configure_and_start(uint64_t ff_disable)
1268 {
1269         struct crypto_testsuite_params *ts_params = &testsuite_params;
1270         struct crypto_unittest_params *ut_params = &unittest_params;
1271
1272         uint16_t qp_id;
1273
1274         /* Clear unit test parameters before running test */
1275         memset(ut_params, 0, sizeof(*ut_params));
1276
1277         /* Reconfigure device to default parameters */
1278         ts_params->conf.socket_id = SOCKET_ID_ANY;
1279         ts_params->conf.ff_disable = ff_disable;
1280         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1281         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1282         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1283
1284         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1285                         &ts_params->conf),
1286                         "Failed to configure cryptodev %u",
1287                         ts_params->valid_devs[0]);
1288
1289         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1290                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1291                         ts_params->valid_devs[0], qp_id,
1292                         &ts_params->qp_conf,
1293                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1294                         "Failed to setup queue pair %u on cryptodev %u",
1295                         qp_id, ts_params->valid_devs[0]);
1296         }
1297
1298
1299         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1300
1301         /* Start the device */
1302         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1303                         "Failed to start cryptodev %u",
1304                         ts_params->valid_devs[0]);
1305
1306         return TEST_SUCCESS;
1307 }
1308
1309 int
1310 ut_setup(void)
1311 {
1312         /* Configure and start the device with security feature disabled */
1313         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1314 }
1315
1316 static int
1317 ut_setup_security(void)
1318 {
1319         /* Configure and start the device with no features disabled */
1320         return dev_configure_and_start(0);
1321 }
1322
1323 void
1324 ut_teardown(void)
1325 {
1326         struct crypto_testsuite_params *ts_params = &testsuite_params;
1327         struct crypto_unittest_params *ut_params = &unittest_params;
1328         struct rte_cryptodev_stats stats;
1329
1330         /* free crypto session structure */
1331 #ifdef RTE_LIB_SECURITY
1332         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1333                 if (ut_params->sec_session) {
1334                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1335                                                 (ts_params->valid_devs[0]),
1336                                                 ut_params->sec_session);
1337                         ut_params->sec_session = NULL;
1338                 }
1339         } else
1340 #endif
1341         {
1342                 if (ut_params->sess) {
1343                         rte_cryptodev_sym_session_clear(
1344                                         ts_params->valid_devs[0],
1345                                         ut_params->sess);
1346                         rte_cryptodev_sym_session_free(ut_params->sess);
1347                         ut_params->sess = NULL;
1348                 }
1349         }
1350
1351         /* free crypto operation structure */
1352         if (ut_params->op)
1353                 rte_crypto_op_free(ut_params->op);
1354
1355         /*
1356          * free mbuf - both obuf and ibuf are usually the same,
1357          * so check if they point at the same address is necessary,
1358          * to avoid freeing the mbuf twice.
1359          */
1360         if (ut_params->obuf) {
1361                 rte_pktmbuf_free(ut_params->obuf);
1362                 if (ut_params->ibuf == ut_params->obuf)
1363                         ut_params->ibuf = 0;
1364                 ut_params->obuf = 0;
1365         }
1366         if (ut_params->ibuf) {
1367                 rte_pktmbuf_free(ut_params->ibuf);
1368                 ut_params->ibuf = 0;
1369         }
1370
1371         if (ts_params->mbuf_pool != NULL)
1372                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1373                         rte_mempool_avail_count(ts_params->mbuf_pool));
1374
1375         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1376
1377         /* Stop the device */
1378         rte_cryptodev_stop(ts_params->valid_devs[0]);
1379 }
1380
1381 static int
1382 test_device_configure_invalid_dev_id(void)
1383 {
1384         struct crypto_testsuite_params *ts_params = &testsuite_params;
1385         uint16_t dev_id, num_devs = 0;
1386
1387         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1388                         "Need at least %d devices for test", 1);
1389
1390         /* valid dev_id values */
1391         dev_id = ts_params->valid_devs[0];
1392
1393         /* Stop the device in case it's started so it can be configured */
1394         rte_cryptodev_stop(dev_id);
1395
1396         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1397                         "Failed test for rte_cryptodev_configure: "
1398                         "invalid dev_num %u", dev_id);
1399
1400         /* invalid dev_id values */
1401         dev_id = num_devs;
1402
1403         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1404                         "Failed test for rte_cryptodev_configure: "
1405                         "invalid dev_num %u", dev_id);
1406
1407         dev_id = 0xff;
1408
1409         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1410                         "Failed test for rte_cryptodev_configure:"
1411                         "invalid dev_num %u", dev_id);
1412
1413         return TEST_SUCCESS;
1414 }
1415
1416 static int
1417 test_device_configure_invalid_queue_pair_ids(void)
1418 {
1419         struct crypto_testsuite_params *ts_params = &testsuite_params;
1420         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1421
1422         /* Stop the device in case it's started so it can be configured */
1423         rte_cryptodev_stop(ts_params->valid_devs[0]);
1424
1425         /* valid - max value queue pairs */
1426         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1427
1428         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1429                         &ts_params->conf),
1430                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1431                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1432
1433         /* valid - one queue pairs */
1434         ts_params->conf.nb_queue_pairs = 1;
1435
1436         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1437                         &ts_params->conf),
1438                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1439                         ts_params->valid_devs[0],
1440                         ts_params->conf.nb_queue_pairs);
1441
1442
1443         /* invalid - zero queue pairs */
1444         ts_params->conf.nb_queue_pairs = 0;
1445
1446         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1447                         &ts_params->conf),
1448                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1449                         " invalid qps: %u",
1450                         ts_params->valid_devs[0],
1451                         ts_params->conf.nb_queue_pairs);
1452
1453
1454         /* invalid - max value supported by field queue pairs */
1455         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1456
1457         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1458                         &ts_params->conf),
1459                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1460                         " invalid qps: %u",
1461                         ts_params->valid_devs[0],
1462                         ts_params->conf.nb_queue_pairs);
1463
1464
1465         /* invalid - max value + 1 queue pairs */
1466         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1467
1468         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1469                         &ts_params->conf),
1470                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1471                         " invalid qps: %u",
1472                         ts_params->valid_devs[0],
1473                         ts_params->conf.nb_queue_pairs);
1474
1475         /* revert to original testsuite value */
1476         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1477
1478         return TEST_SUCCESS;
1479 }
1480
1481 static int
1482 test_queue_pair_descriptor_setup(void)
1483 {
1484         struct crypto_testsuite_params *ts_params = &testsuite_params;
1485         struct rte_cryptodev_qp_conf qp_conf = {
1486                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1487         };
1488         uint16_t qp_id;
1489
1490         /* Stop the device in case it's started so it can be configured */
1491         rte_cryptodev_stop(ts_params->valid_devs[0]);
1492
1493         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1494                         &ts_params->conf),
1495                         "Failed to configure cryptodev %u",
1496                         ts_params->valid_devs[0]);
1497
1498         /*
1499          * Test various ring sizes on this device. memzones can't be
1500          * freed so are re-used if ring is released and re-created.
1501          */
1502         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1503         qp_conf.mp_session = ts_params->session_mpool;
1504         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1505
1506         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1507                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1508                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1509                                 rte_cryptodev_socket_id(
1510                                                 ts_params->valid_devs[0])),
1511                                 "Failed test for "
1512                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1513                                 "%u on qp %u on cryptodev %u",
1514                                 qp_conf.nb_descriptors, qp_id,
1515                                 ts_params->valid_devs[0]);
1516         }
1517
1518         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1519
1520         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1521                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1522                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1523                                 rte_cryptodev_socket_id(
1524                                                 ts_params->valid_devs[0])),
1525                                 "Failed test for"
1526                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1527                                 " %u on qp %u on cryptodev %u",
1528                                 qp_conf.nb_descriptors, qp_id,
1529                                 ts_params->valid_devs[0]);
1530         }
1531
1532         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1533
1534         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1535                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1536                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1537                                 rte_cryptodev_socket_id(
1538                                                 ts_params->valid_devs[0])),
1539                                 "Failed test for "
1540                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1541                                 " %u on qp %u on cryptodev %u",
1542                                 qp_conf.nb_descriptors, qp_id,
1543                                 ts_params->valid_devs[0]);
1544         }
1545
1546         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1547
1548         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1549                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1550                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1551                                 rte_cryptodev_socket_id(
1552                                                 ts_params->valid_devs[0])),
1553                                 "Failed test for"
1554                                 " rte_cryptodev_queue_pair_setup:"
1555                                 "num_inflights %u on qp %u on cryptodev %u",
1556                                 qp_conf.nb_descriptors, qp_id,
1557                                 ts_params->valid_devs[0]);
1558         }
1559
1560         /* test invalid queue pair id */
1561         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1562
1563         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1564
1565         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1566                         ts_params->valid_devs[0],
1567                         qp_id, &qp_conf,
1568                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1569                         "Failed test for rte_cryptodev_queue_pair_setup:"
1570                         "invalid qp %u on cryptodev %u",
1571                         qp_id, ts_params->valid_devs[0]);
1572
1573         qp_id = 0xffff; /*invalid*/
1574
1575         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1576                         ts_params->valid_devs[0],
1577                         qp_id, &qp_conf,
1578                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1579                         "Failed test for rte_cryptodev_queue_pair_setup:"
1580                         "invalid qp %u on cryptodev %u",
1581                         qp_id, ts_params->valid_devs[0]);
1582
1583         return TEST_SUCCESS;
1584 }
1585
1586 /* ***** Plaintext data for tests ***** */
1587
1588 const char catch_22_quote_1[] =
1589                 "There was only one catch and that was Catch-22, which "
1590                 "specified that a concern for one's safety in the face of "
1591                 "dangers that were real and immediate was the process of a "
1592                 "rational mind. Orr was crazy and could be grounded. All he "
1593                 "had to do was ask; and as soon as he did, he would no longer "
1594                 "be crazy and would have to fly more missions. Orr would be "
1595                 "crazy to fly more missions and sane if he didn't, but if he "
1596                 "was sane he had to fly them. If he flew them he was crazy "
1597                 "and didn't have to; but if he didn't want to he was sane and "
1598                 "had to. Yossarian was moved very deeply by the absolute "
1599                 "simplicity of this clause of Catch-22 and let out a "
1600                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1601                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1602
1603 const char catch_22_quote[] =
1604                 "What a lousy earth! He wondered how many people were "
1605                 "destitute that same night even in his own prosperous country, "
1606                 "how many homes were shanties, how many husbands were drunk "
1607                 "and wives socked, and how many children were bullied, abused, "
1608                 "or abandoned. How many families hungered for food they could "
1609                 "not afford to buy? How many hearts were broken? How many "
1610                 "suicides would take place that same night, how many people "
1611                 "would go insane? How many cockroaches and landlords would "
1612                 "triumph? How many winners were losers, successes failures, "
1613                 "and rich men poor men? How many wise guys were stupid? How "
1614                 "many happy endings were unhappy endings? How many honest men "
1615                 "were liars, brave men cowards, loyal men traitors, how many "
1616                 "sainted men were corrupt, how many people in positions of "
1617                 "trust had sold their souls to bodyguards, how many had never "
1618                 "had souls? How many straight-and-narrow paths were crooked "
1619                 "paths? How many best families were worst families and how "
1620                 "many good people were bad people? When you added them all up "
1621                 "and then subtracted, you might be left with only the children, "
1622                 "and perhaps with Albert Einstein and an old violinist or "
1623                 "sculptor somewhere.";
1624
1625 #define QUOTE_480_BYTES         (480)
1626 #define QUOTE_512_BYTES         (512)
1627 #define QUOTE_768_BYTES         (768)
1628 #define QUOTE_1024_BYTES        (1024)
1629
1630
1631
1632 /* ***** SHA1 Hash Tests ***** */
1633
1634 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1635
1636 static uint8_t hmac_sha1_key[] = {
1637         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1638         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1639         0xDE, 0xF4, 0xDE, 0xAD };
1640
1641 /* ***** SHA224 Hash Tests ***** */
1642
1643 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1644
1645
1646 /* ***** AES-CBC Cipher Tests ***** */
1647
1648 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1649 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1650
1651 static uint8_t aes_cbc_key[] = {
1652         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1653         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1654
1655 static uint8_t aes_cbc_iv[] = {
1656         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1657         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1658
1659
1660 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1661
1662 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1663         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1664         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1665         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1666         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1667         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1668         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1669         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1670         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1671         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1672         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1673         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1674         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1675         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1676         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1677         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1678         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1679         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1680         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1681         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1682         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1683         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1684         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1685         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1686         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1687         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1688         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1689         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1690         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1691         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1692         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1693         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1694         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1695         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1696         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1697         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1698         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1699         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1700         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1701         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1702         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1703         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1704         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1705         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1706         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1707         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1708         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1709         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1710         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1711         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1712         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1713         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1714         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1715         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1716         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1717         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1718         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1719         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1720         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1721         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1722         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1723         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1724         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1725         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1726         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1727 };
1728
1729 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1730         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1731         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1732         0x18, 0x8c, 0x1d, 0x32
1733 };
1734
1735
1736 /* Multisession Vector context Test */
1737 /*Begin Session 0 */
1738 static uint8_t ms_aes_cbc_key0[] = {
1739         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1740         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1741 };
1742
1743 static uint8_t ms_aes_cbc_iv0[] = {
1744         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1745         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1746 };
1747
1748 static const uint8_t ms_aes_cbc_cipher0[] = {
1749                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1750                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1751                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1752                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1753                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1754                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1755                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1756                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1757                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1758                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1759                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1760                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1761                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1762                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1763                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1764                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1765                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1766                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1767                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1768                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1769                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1770                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1771                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1772                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1773                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1774                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1775                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1776                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1777                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1778                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1779                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1780                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1781                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1782                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1783                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1784                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1785                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1786                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1787                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1788                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1789                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1790                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1791                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1792                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1793                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1794                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1795                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1796                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1797                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1798                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1799                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1800                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1801                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1802                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1803                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1804                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1805                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1806                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1807                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1808                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1809                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1810                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1811                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1812                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1813 };
1814
1815
1816 static  uint8_t ms_hmac_key0[] = {
1817                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1818                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1819                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1820                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1821                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1822                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1823                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1824                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1825 };
1826
1827 static const uint8_t ms_hmac_digest0[] = {
1828                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1829                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1830                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1831                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1832                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1833                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1834                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1835                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1836                 };
1837
1838 /* End Session 0 */
1839 /* Begin session 1 */
1840
1841 static  uint8_t ms_aes_cbc_key1[] = {
1842                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1843                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1844 };
1845
1846 static  uint8_t ms_aes_cbc_iv1[] = {
1847         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1848         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1849 };
1850
1851 static const uint8_t ms_aes_cbc_cipher1[] = {
1852                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1853                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1854                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1855                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1856                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1857                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1858                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1859                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1860                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1861                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1862                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1863                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1864                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1865                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1866                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1867                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1868                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1869                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1870                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1871                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1872                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1873                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1874                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1875                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1876                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1877                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1878                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1879                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1880                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1881                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1882                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1883                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1884                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1885                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1886                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1887                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1888                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1889                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1890                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1891                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1892                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1893                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1894                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1895                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1896                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1897                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1898                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1899                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1900                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1901                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1902                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1903                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1904                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1905                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1906                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1907                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1908                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1909                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1910                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1911                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1912                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1913                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1914                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1915                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1916
1917 };
1918
1919 static uint8_t ms_hmac_key1[] = {
1920                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1921                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1922                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1923                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1924                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1925                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1926                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1927                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1928 };
1929
1930 static const uint8_t ms_hmac_digest1[] = {
1931                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1932                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1933                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1934                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1935                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1936                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1937                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1938                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1939 };
1940 /* End Session 1  */
1941 /* Begin Session 2 */
1942 static  uint8_t ms_aes_cbc_key2[] = {
1943                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1944                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1945 };
1946
1947 static  uint8_t ms_aes_cbc_iv2[] = {
1948                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1949                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1950 };
1951
1952 static const uint8_t ms_aes_cbc_cipher2[] = {
1953                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1954                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1955                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1956                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1957                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1958                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1959                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1960                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1961                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1962                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1963                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1964                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1965                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1966                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1967                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1968                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1969                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1970                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1971                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1972                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1973                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1974                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1975                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1976                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1977                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1978                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1979                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1980                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1981                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1982                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1983                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1984                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1985                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1986                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1987                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1988                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1989                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1990                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1991                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1992                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1993                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1994                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1995                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1996                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1997                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1998                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1999                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2000                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2001                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2002                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2003                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2004                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2005                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2006                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2007                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2008                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2009                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2010                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2011                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2012                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2013                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2014                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2015                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2016                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2017 };
2018
2019 static  uint8_t ms_hmac_key2[] = {
2020                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2021                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2022                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2023                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2024                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2025                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2026                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2027                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2028 };
2029
2030 static const uint8_t ms_hmac_digest2[] = {
2031                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2032                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2033                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2034                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2035                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2036                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2037                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2038                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2039 };
2040
2041 /* End Session 2 */
2042
2043
2044 static int
2045 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2046 {
2047         struct crypto_testsuite_params *ts_params = &testsuite_params;
2048         struct crypto_unittest_params *ut_params = &unittest_params;
2049
2050         /* Verify the capabilities */
2051         struct rte_cryptodev_sym_capability_idx cap_idx;
2052         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2053         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2054         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2055                         &cap_idx) == NULL)
2056                 return TEST_SKIPPED;
2057         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2058         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2059         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2060                         &cap_idx) == NULL)
2061                 return TEST_SKIPPED;
2062
2063         /* Generate test mbuf data and space for digest */
2064         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2065                         catch_22_quote, QUOTE_512_BYTES, 0);
2066
2067         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2068                         DIGEST_BYTE_LENGTH_SHA1);
2069         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2070
2071         /* Setup Cipher Parameters */
2072         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2073         ut_params->cipher_xform.next = &ut_params->auth_xform;
2074
2075         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2076         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2077         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2078         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2079         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2080         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2081
2082         /* Setup HMAC Parameters */
2083         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2084
2085         ut_params->auth_xform.next = NULL;
2086
2087         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2088         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2089         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2090         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2091         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2092
2093         ut_params->sess = rte_cryptodev_sym_session_create(
2094                         ts_params->session_mpool);
2095
2096         /* Create crypto session*/
2097         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2098                         ut_params->sess, &ut_params->cipher_xform,
2099                         ts_params->session_priv_mpool);
2100         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2101
2102         /* Generate crypto op data structure */
2103         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2104                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2105         TEST_ASSERT_NOT_NULL(ut_params->op,
2106                         "Failed to allocate symmetric crypto operation struct");
2107
2108         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2109
2110         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2111
2112         /* set crypto operation source mbuf */
2113         sym_op->m_src = ut_params->ibuf;
2114
2115         /* Set crypto operation authentication parameters */
2116         sym_op->auth.digest.data = ut_params->digest;
2117         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2118                         ut_params->ibuf, QUOTE_512_BYTES);
2119
2120         sym_op->auth.data.offset = 0;
2121         sym_op->auth.data.length = QUOTE_512_BYTES;
2122
2123         /* Copy IV at the end of the crypto operation */
2124         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2125                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2126
2127         /* Set crypto operation cipher parameters */
2128         sym_op->cipher.data.offset = 0;
2129         sym_op->cipher.data.length = QUOTE_512_BYTES;
2130
2131         /* Process crypto operation */
2132         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2133                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2134                         ut_params->op);
2135         else
2136                 TEST_ASSERT_NOT_NULL(
2137                         process_crypto_request(ts_params->valid_devs[0],
2138                                 ut_params->op),
2139                                 "failed to process sym crypto op");
2140
2141         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2142                         "crypto op processing failed");
2143
2144         /* Validate obuf */
2145         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2146                         uint8_t *);
2147
2148         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2149                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2150                         QUOTE_512_BYTES,
2151                         "ciphertext data not as expected");
2152
2153         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2154
2155         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2156                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2157                         gbl_driver_id == rte_cryptodev_driver_id_get(
2158                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2159                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2160                                         DIGEST_BYTE_LENGTH_SHA1,
2161                         "Generated digest data not as expected");
2162
2163         return TEST_SUCCESS;
2164 }
2165
2166 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2167
2168 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2169
2170 static uint8_t hmac_sha512_key[] = {
2171         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2172         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2173         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2174         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2175         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2176         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2177         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2178         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2179
2180 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2181         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2182         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2183         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2184         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2185         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2186         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2187         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2188         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2189
2190
2191
2192 static int
2193 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2194                 struct crypto_unittest_params *ut_params,
2195                 uint8_t *cipher_key,
2196                 uint8_t *hmac_key);
2197
2198 static int
2199 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2200                 struct crypto_unittest_params *ut_params,
2201                 struct crypto_testsuite_params *ts_params,
2202                 const uint8_t *cipher,
2203                 const uint8_t *digest,
2204                 const uint8_t *iv);
2205
2206
2207 static int
2208 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2209                 struct crypto_unittest_params *ut_params,
2210                 uint8_t *cipher_key,
2211                 uint8_t *hmac_key)
2212 {
2213
2214         /* Setup Cipher Parameters */
2215         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2216         ut_params->cipher_xform.next = NULL;
2217
2218         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2219         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2220         ut_params->cipher_xform.cipher.key.data = cipher_key;
2221         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2222         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2223         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2224
2225         /* Setup HMAC Parameters */
2226         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2227         ut_params->auth_xform.next = &ut_params->cipher_xform;
2228
2229         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2230         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2231         ut_params->auth_xform.auth.key.data = hmac_key;
2232         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2233         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2234
2235         return TEST_SUCCESS;
2236 }
2237
2238
2239 static int
2240 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2241                 struct crypto_unittest_params *ut_params,
2242                 struct crypto_testsuite_params *ts_params,
2243                 const uint8_t *cipher,
2244                 const uint8_t *digest,
2245                 const uint8_t *iv)
2246 {
2247         /* Generate test mbuf data and digest */
2248         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2249                         (const char *)
2250                         cipher,
2251                         QUOTE_512_BYTES, 0);
2252
2253         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2254                         DIGEST_BYTE_LENGTH_SHA512);
2255         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2256
2257         rte_memcpy(ut_params->digest,
2258                         digest,
2259                         DIGEST_BYTE_LENGTH_SHA512);
2260
2261         /* Generate Crypto op data structure */
2262         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2263                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2264         TEST_ASSERT_NOT_NULL(ut_params->op,
2265                         "Failed to allocate symmetric crypto operation struct");
2266
2267         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2268
2269         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2270
2271         /* set crypto operation source mbuf */
2272         sym_op->m_src = ut_params->ibuf;
2273
2274         sym_op->auth.digest.data = ut_params->digest;
2275         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2276                         ut_params->ibuf, QUOTE_512_BYTES);
2277
2278         sym_op->auth.data.offset = 0;
2279         sym_op->auth.data.length = QUOTE_512_BYTES;
2280
2281         /* Copy IV at the end of the crypto operation */
2282         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2283                         iv, CIPHER_IV_LENGTH_AES_CBC);
2284
2285         sym_op->cipher.data.offset = 0;
2286         sym_op->cipher.data.length = QUOTE_512_BYTES;
2287
2288         /* Process crypto operation */
2289         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2290                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2291                         ut_params->op);
2292         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2293                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2294                                 ut_params->op, 1, 1, 0, 0);
2295         else
2296                 TEST_ASSERT_NOT_NULL(
2297                                 process_crypto_request(ts_params->valid_devs[0],
2298                                         ut_params->op),
2299                                         "failed to process sym crypto op");
2300
2301         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2302                         "crypto op processing failed");
2303
2304         ut_params->obuf = ut_params->op->sym->m_src;
2305
2306         /* Validate obuf */
2307         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2308                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2309                         catch_22_quote,
2310                         QUOTE_512_BYTES,
2311                         "Plaintext data not as expected");
2312
2313         /* Validate obuf */
2314         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2315                         "Digest verification failed");
2316
2317         return TEST_SUCCESS;
2318 }
2319
2320 /* ***** SNOW 3G Tests ***** */
2321 static int
2322 create_wireless_algo_hash_session(uint8_t dev_id,
2323         const uint8_t *key, const uint8_t key_len,
2324         const uint8_t iv_len, const uint8_t auth_len,
2325         enum rte_crypto_auth_operation op,
2326         enum rte_crypto_auth_algorithm algo)
2327 {
2328         uint8_t hash_key[key_len];
2329         int status;
2330
2331         struct crypto_testsuite_params *ts_params = &testsuite_params;
2332         struct crypto_unittest_params *ut_params = &unittest_params;
2333
2334         memcpy(hash_key, key, key_len);
2335
2336         debug_hexdump(stdout, "key:", key, key_len);
2337
2338         /* Setup Authentication Parameters */
2339         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2340         ut_params->auth_xform.next = NULL;
2341
2342         ut_params->auth_xform.auth.op = op;
2343         ut_params->auth_xform.auth.algo = algo;
2344         ut_params->auth_xform.auth.key.length = key_len;
2345         ut_params->auth_xform.auth.key.data = hash_key;
2346         ut_params->auth_xform.auth.digest_length = auth_len;
2347         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2348         ut_params->auth_xform.auth.iv.length = iv_len;
2349         ut_params->sess = rte_cryptodev_sym_session_create(
2350                         ts_params->session_mpool);
2351
2352         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2353                         &ut_params->auth_xform,
2354                         ts_params->session_priv_mpool);
2355         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2356         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2357         return 0;
2358 }
2359
2360 static int
2361 create_wireless_algo_cipher_session(uint8_t dev_id,
2362                         enum rte_crypto_cipher_operation op,
2363                         enum rte_crypto_cipher_algorithm algo,
2364                         const uint8_t *key, const uint8_t key_len,
2365                         uint8_t iv_len)
2366 {
2367         uint8_t cipher_key[key_len];
2368         int status;
2369         struct crypto_testsuite_params *ts_params = &testsuite_params;
2370         struct crypto_unittest_params *ut_params = &unittest_params;
2371
2372         memcpy(cipher_key, key, key_len);
2373
2374         /* Setup Cipher Parameters */
2375         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2376         ut_params->cipher_xform.next = NULL;
2377
2378         ut_params->cipher_xform.cipher.algo = algo;
2379         ut_params->cipher_xform.cipher.op = op;
2380         ut_params->cipher_xform.cipher.key.data = cipher_key;
2381         ut_params->cipher_xform.cipher.key.length = key_len;
2382         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2383         ut_params->cipher_xform.cipher.iv.length = iv_len;
2384
2385         debug_hexdump(stdout, "key:", key, key_len);
2386
2387         /* Create Crypto session */
2388         ut_params->sess = rte_cryptodev_sym_session_create(
2389                         ts_params->session_mpool);
2390
2391         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2392                         &ut_params->cipher_xform,
2393                         ts_params->session_priv_mpool);
2394         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2395         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2396         return 0;
2397 }
2398
2399 static int
2400 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2401                         unsigned int cipher_len,
2402                         unsigned int cipher_offset)
2403 {
2404         struct crypto_testsuite_params *ts_params = &testsuite_params;
2405         struct crypto_unittest_params *ut_params = &unittest_params;
2406
2407         /* Generate Crypto op data structure */
2408         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2409                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2410         TEST_ASSERT_NOT_NULL(ut_params->op,
2411                                 "Failed to allocate pktmbuf offload");
2412
2413         /* Set crypto operation data parameters */
2414         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2415
2416         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2417
2418         /* set crypto operation source mbuf */
2419         sym_op->m_src = ut_params->ibuf;
2420
2421         /* iv */
2422         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2423                         iv, iv_len);
2424         sym_op->cipher.data.length = cipher_len;
2425         sym_op->cipher.data.offset = cipher_offset;
2426         return 0;
2427 }
2428
2429 static int
2430 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2431                         unsigned int cipher_len,
2432                         unsigned int cipher_offset)
2433 {
2434         struct crypto_testsuite_params *ts_params = &testsuite_params;
2435         struct crypto_unittest_params *ut_params = &unittest_params;
2436
2437         /* Generate Crypto op data structure */
2438         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2439                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2440         TEST_ASSERT_NOT_NULL(ut_params->op,
2441                                 "Failed to allocate pktmbuf offload");
2442
2443         /* Set crypto operation data parameters */
2444         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2445
2446         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2447
2448         /* set crypto operation source mbuf */
2449         sym_op->m_src = ut_params->ibuf;
2450         sym_op->m_dst = ut_params->obuf;
2451
2452         /* iv */
2453         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2454                         iv, iv_len);
2455         sym_op->cipher.data.length = cipher_len;
2456         sym_op->cipher.data.offset = cipher_offset;
2457         return 0;
2458 }
2459
2460 static int
2461 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2462                 enum rte_crypto_cipher_operation cipher_op,
2463                 enum rte_crypto_auth_operation auth_op,
2464                 enum rte_crypto_auth_algorithm auth_algo,
2465                 enum rte_crypto_cipher_algorithm cipher_algo,
2466                 const uint8_t *key, uint8_t key_len,
2467                 uint8_t auth_iv_len, uint8_t auth_len,
2468                 uint8_t cipher_iv_len)
2469
2470 {
2471         uint8_t cipher_auth_key[key_len];
2472         int status;
2473
2474         struct crypto_testsuite_params *ts_params = &testsuite_params;
2475         struct crypto_unittest_params *ut_params = &unittest_params;
2476
2477         memcpy(cipher_auth_key, key, key_len);
2478
2479         /* Setup Authentication Parameters */
2480         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2481         ut_params->auth_xform.next = NULL;
2482
2483         ut_params->auth_xform.auth.op = auth_op;
2484         ut_params->auth_xform.auth.algo = auth_algo;
2485         ut_params->auth_xform.auth.key.length = key_len;
2486         /* Hash key = cipher key */
2487         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2488         ut_params->auth_xform.auth.digest_length = auth_len;
2489         /* Auth IV will be after cipher IV */
2490         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2491         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2492
2493         /* Setup Cipher Parameters */
2494         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2495         ut_params->cipher_xform.next = &ut_params->auth_xform;
2496
2497         ut_params->cipher_xform.cipher.algo = cipher_algo;
2498         ut_params->cipher_xform.cipher.op = cipher_op;
2499         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2500         ut_params->cipher_xform.cipher.key.length = key_len;
2501         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2502         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2503
2504         debug_hexdump(stdout, "key:", key, key_len);
2505
2506         /* Create Crypto session*/
2507         ut_params->sess = rte_cryptodev_sym_session_create(
2508                         ts_params->session_mpool);
2509         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2510
2511         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2512                         &ut_params->cipher_xform,
2513                         ts_params->session_priv_mpool);
2514         if (status == -ENOTSUP)
2515                 return TEST_SKIPPED;
2516
2517         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2518         return 0;
2519 }
2520
2521 static int
2522 create_wireless_cipher_auth_session(uint8_t dev_id,
2523                 enum rte_crypto_cipher_operation cipher_op,
2524                 enum rte_crypto_auth_operation auth_op,
2525                 enum rte_crypto_auth_algorithm auth_algo,
2526                 enum rte_crypto_cipher_algorithm cipher_algo,
2527                 const struct wireless_test_data *tdata)
2528 {
2529         const uint8_t key_len = tdata->key.len;
2530         uint8_t cipher_auth_key[key_len];
2531         int status;
2532
2533         struct crypto_testsuite_params *ts_params = &testsuite_params;
2534         struct crypto_unittest_params *ut_params = &unittest_params;
2535         const uint8_t *key = tdata->key.data;
2536         const uint8_t auth_len = tdata->digest.len;
2537         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2538         uint8_t auth_iv_len = tdata->auth_iv.len;
2539
2540         memcpy(cipher_auth_key, key, key_len);
2541
2542         /* Setup Authentication Parameters */
2543         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2544         ut_params->auth_xform.next = NULL;
2545
2546         ut_params->auth_xform.auth.op = auth_op;
2547         ut_params->auth_xform.auth.algo = auth_algo;
2548         ut_params->auth_xform.auth.key.length = key_len;
2549         /* Hash key = cipher key */
2550         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2551         ut_params->auth_xform.auth.digest_length = auth_len;
2552         /* Auth IV will be after cipher IV */
2553         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2554         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2555
2556         /* Setup Cipher Parameters */
2557         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2558         ut_params->cipher_xform.next = &ut_params->auth_xform;
2559
2560         ut_params->cipher_xform.cipher.algo = cipher_algo;
2561         ut_params->cipher_xform.cipher.op = cipher_op;
2562         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2563         ut_params->cipher_xform.cipher.key.length = key_len;
2564         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2565         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2566
2567
2568         debug_hexdump(stdout, "key:", key, key_len);
2569
2570         /* Create Crypto session*/
2571         ut_params->sess = rte_cryptodev_sym_session_create(
2572                         ts_params->session_mpool);
2573
2574         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2575                         &ut_params->cipher_xform,
2576                         ts_params->session_priv_mpool);
2577         if (status == -ENOTSUP)
2578                 return TEST_SKIPPED;
2579
2580         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2581         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2582         return 0;
2583 }
2584
2585 static int
2586 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2587                 const struct wireless_test_data *tdata)
2588 {
2589         return create_wireless_cipher_auth_session(dev_id,
2590                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2591                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2592                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2593 }
2594
2595 static int
2596 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2597                 enum rte_crypto_cipher_operation cipher_op,
2598                 enum rte_crypto_auth_operation auth_op,
2599                 enum rte_crypto_auth_algorithm auth_algo,
2600                 enum rte_crypto_cipher_algorithm cipher_algo,
2601                 const uint8_t *key, const uint8_t key_len,
2602                 uint8_t auth_iv_len, uint8_t auth_len,
2603                 uint8_t cipher_iv_len)
2604 {
2605         uint8_t auth_cipher_key[key_len];
2606         int status;
2607         struct crypto_testsuite_params *ts_params = &testsuite_params;
2608         struct crypto_unittest_params *ut_params = &unittest_params;
2609
2610         memcpy(auth_cipher_key, key, key_len);
2611
2612         /* Setup Authentication Parameters */
2613         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2614         ut_params->auth_xform.auth.op = auth_op;
2615         ut_params->auth_xform.next = &ut_params->cipher_xform;
2616         ut_params->auth_xform.auth.algo = auth_algo;
2617         ut_params->auth_xform.auth.key.length = key_len;
2618         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2619         ut_params->auth_xform.auth.digest_length = auth_len;
2620         /* Auth IV will be after cipher IV */
2621         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2622         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2623
2624         /* Setup Cipher Parameters */
2625         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2626         ut_params->cipher_xform.next = NULL;
2627         ut_params->cipher_xform.cipher.algo = cipher_algo;
2628         ut_params->cipher_xform.cipher.op = cipher_op;
2629         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2630         ut_params->cipher_xform.cipher.key.length = key_len;
2631         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2632         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2633
2634         debug_hexdump(stdout, "key:", key, key_len);
2635
2636         /* Create Crypto session*/
2637         ut_params->sess = rte_cryptodev_sym_session_create(
2638                         ts_params->session_mpool);
2639         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2640
2641         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2642                 ut_params->auth_xform.next = NULL;
2643                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2644                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2645                                 &ut_params->cipher_xform,
2646                                 ts_params->session_priv_mpool);
2647
2648         } else
2649                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2650                                 &ut_params->auth_xform,
2651                                 ts_params->session_priv_mpool);
2652
2653         if (status == -ENOTSUP)
2654                 return TEST_SKIPPED;
2655
2656         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2657
2658         return 0;
2659 }
2660
2661 static int
2662 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2663                 unsigned int auth_tag_len,
2664                 const uint8_t *iv, unsigned int iv_len,
2665                 unsigned int data_pad_len,
2666                 enum rte_crypto_auth_operation op,
2667                 unsigned int auth_len, unsigned int auth_offset)
2668 {
2669         struct crypto_testsuite_params *ts_params = &testsuite_params;
2670
2671         struct crypto_unittest_params *ut_params = &unittest_params;
2672
2673         /* Generate Crypto op data structure */
2674         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2675                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2676         TEST_ASSERT_NOT_NULL(ut_params->op,
2677                 "Failed to allocate pktmbuf offload");
2678
2679         /* Set crypto operation data parameters */
2680         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2681
2682         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2683
2684         /* set crypto operation source mbuf */
2685         sym_op->m_src = ut_params->ibuf;
2686
2687         /* iv */
2688         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2689                         iv, iv_len);
2690         /* digest */
2691         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2692                                         ut_params->ibuf, auth_tag_len);
2693
2694         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2695                                 "no room to append auth tag");
2696         ut_params->digest = sym_op->auth.digest.data;
2697         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2698                         ut_params->ibuf, data_pad_len);
2699         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2700                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2701         else
2702                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2703
2704         debug_hexdump(stdout, "digest:",
2705                 sym_op->auth.digest.data,
2706                 auth_tag_len);
2707
2708         sym_op->auth.data.length = auth_len;
2709         sym_op->auth.data.offset = auth_offset;
2710
2711         return 0;
2712 }
2713
2714 static int
2715 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2716         enum rte_crypto_auth_operation op)
2717 {
2718         struct crypto_testsuite_params *ts_params = &testsuite_params;
2719         struct crypto_unittest_params *ut_params = &unittest_params;
2720
2721         const uint8_t *auth_tag = tdata->digest.data;
2722         const unsigned int auth_tag_len = tdata->digest.len;
2723         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2724         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2725
2726         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2727         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2728         const uint8_t *auth_iv = tdata->auth_iv.data;
2729         const uint8_t auth_iv_len = tdata->auth_iv.len;
2730         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2731         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2732
2733         /* Generate Crypto op data structure */
2734         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2735                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2736         TEST_ASSERT_NOT_NULL(ut_params->op,
2737                         "Failed to allocate pktmbuf offload");
2738         /* Set crypto operation data parameters */
2739         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2740
2741         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2742
2743         /* set crypto operation source mbuf */
2744         sym_op->m_src = ut_params->ibuf;
2745
2746         /* digest */
2747         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2748                         ut_params->ibuf, auth_tag_len);
2749
2750         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2751                         "no room to append auth tag");
2752         ut_params->digest = sym_op->auth.digest.data;
2753         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2754                         ut_params->ibuf, data_pad_len);
2755         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2756                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2757         else
2758                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2759
2760         debug_hexdump(stdout, "digest:",
2761                 sym_op->auth.digest.data,
2762                 auth_tag_len);
2763
2764         /* Copy cipher and auth IVs at the end of the crypto operation */
2765         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2766                                                 IV_OFFSET);
2767         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2768         iv_ptr += cipher_iv_len;
2769         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2770
2771         sym_op->cipher.data.length = cipher_len;
2772         sym_op->cipher.data.offset = 0;
2773         sym_op->auth.data.length = auth_len;
2774         sym_op->auth.data.offset = 0;
2775
2776         return 0;
2777 }
2778
2779 static int
2780 create_zuc_cipher_hash_generate_operation(
2781                 const struct wireless_test_data *tdata)
2782 {
2783         return create_wireless_cipher_hash_operation(tdata,
2784                 RTE_CRYPTO_AUTH_OP_GENERATE);
2785 }
2786
2787 static int
2788 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2789                 const unsigned auth_tag_len,
2790                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2791                 unsigned data_pad_len,
2792                 enum rte_crypto_auth_operation op,
2793                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2794                 const unsigned cipher_len, const unsigned cipher_offset,
2795                 const unsigned auth_len, const unsigned auth_offset)
2796 {
2797         struct crypto_testsuite_params *ts_params = &testsuite_params;
2798         struct crypto_unittest_params *ut_params = &unittest_params;
2799
2800         enum rte_crypto_cipher_algorithm cipher_algo =
2801                         ut_params->cipher_xform.cipher.algo;
2802         enum rte_crypto_auth_algorithm auth_algo =
2803                         ut_params->auth_xform.auth.algo;
2804
2805         /* Generate Crypto op data structure */
2806         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2807                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2808         TEST_ASSERT_NOT_NULL(ut_params->op,
2809                         "Failed to allocate pktmbuf offload");
2810         /* Set crypto operation data parameters */
2811         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2812
2813         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2814
2815         /* set crypto operation source mbuf */
2816         sym_op->m_src = ut_params->ibuf;
2817
2818         /* digest */
2819         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2820                         ut_params->ibuf, auth_tag_len);
2821
2822         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2823                         "no room to append auth tag");
2824         ut_params->digest = sym_op->auth.digest.data;
2825
2826         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2827                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2828                                 ut_params->ibuf, data_pad_len);
2829         } else {
2830                 struct rte_mbuf *m = ut_params->ibuf;
2831                 unsigned int offset = data_pad_len;
2832
2833                 while (offset > m->data_len && m->next != NULL) {
2834                         offset -= m->data_len;
2835                         m = m->next;
2836                 }
2837                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2838                         m, offset);
2839         }
2840
2841         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2842                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2843         else
2844                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2845
2846         debug_hexdump(stdout, "digest:",
2847                 sym_op->auth.digest.data,
2848                 auth_tag_len);
2849
2850         /* Copy cipher and auth IVs at the end of the crypto operation */
2851         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2852                                                 IV_OFFSET);
2853         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2854         iv_ptr += cipher_iv_len;
2855         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2856
2857         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2858                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2859                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2860                 sym_op->cipher.data.length = cipher_len;
2861                 sym_op->cipher.data.offset = cipher_offset;
2862         } else {
2863                 sym_op->cipher.data.length = cipher_len >> 3;
2864                 sym_op->cipher.data.offset = cipher_offset >> 3;
2865         }
2866
2867         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2868                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2869                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2870                 sym_op->auth.data.length = auth_len;
2871                 sym_op->auth.data.offset = auth_offset;
2872         } else {
2873                 sym_op->auth.data.length = auth_len >> 3;
2874                 sym_op->auth.data.offset = auth_offset >> 3;
2875         }
2876
2877         return 0;
2878 }
2879
2880 static int
2881 create_wireless_algo_auth_cipher_operation(
2882                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2883                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2884                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2885                 unsigned int data_pad_len,
2886                 unsigned int cipher_len, unsigned int cipher_offset,
2887                 unsigned int auth_len, unsigned int auth_offset,
2888                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2889 {
2890         struct crypto_testsuite_params *ts_params = &testsuite_params;
2891         struct crypto_unittest_params *ut_params = &unittest_params;
2892
2893         enum rte_crypto_cipher_algorithm cipher_algo =
2894                         ut_params->cipher_xform.cipher.algo;
2895         enum rte_crypto_auth_algorithm auth_algo =
2896                         ut_params->auth_xform.auth.algo;
2897
2898         /* Generate Crypto op data structure */
2899         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2900                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2901         TEST_ASSERT_NOT_NULL(ut_params->op,
2902                         "Failed to allocate pktmbuf offload");
2903
2904         /* Set crypto operation data parameters */
2905         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2906
2907         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2908
2909         /* set crypto operation mbufs */
2910         sym_op->m_src = ut_params->ibuf;
2911         if (op_mode == OUT_OF_PLACE)
2912                 sym_op->m_dst = ut_params->obuf;
2913
2914         /* digest */
2915         if (!do_sgl) {
2916                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2917                         (op_mode == IN_PLACE ?
2918                                 ut_params->ibuf : ut_params->obuf),
2919                         uint8_t *, data_pad_len);
2920                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2921                         (op_mode == IN_PLACE ?
2922                                 ut_params->ibuf : ut_params->obuf),
2923                         data_pad_len);
2924                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2925         } else {
2926                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2927                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2928                                 sym_op->m_src : sym_op->m_dst);
2929                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2930                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2931                         sgl_buf = sgl_buf->next;
2932                 }
2933                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2934                                 uint8_t *, remaining_off);
2935                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2936                                 remaining_off);
2937                 memset(sym_op->auth.digest.data, 0, remaining_off);
2938                 while (sgl_buf->next != NULL) {
2939                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2940                                 0, rte_pktmbuf_data_len(sgl_buf));
2941                         sgl_buf = sgl_buf->next;
2942                 }
2943         }
2944
2945         /* Copy digest for the verification */
2946         if (verify)
2947                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2948
2949         /* Copy cipher and auth IVs at the end of the crypto operation */
2950         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2951                         ut_params->op, uint8_t *, IV_OFFSET);
2952
2953         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2954         iv_ptr += cipher_iv_len;
2955         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2956
2957         /* Only copy over the offset data needed from src to dst in OOP,
2958          * if the auth and cipher offsets are not aligned
2959          */
2960         if (op_mode == OUT_OF_PLACE) {
2961                 if (cipher_offset > auth_offset)
2962                         rte_memcpy(
2963                                 rte_pktmbuf_mtod_offset(
2964                                         sym_op->m_dst,
2965                                         uint8_t *, auth_offset >> 3),
2966                                 rte_pktmbuf_mtod_offset(
2967                                         sym_op->m_src,
2968                                         uint8_t *, auth_offset >> 3),
2969                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
2970         }
2971
2972         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2973                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2974                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2975                 sym_op->cipher.data.length = cipher_len;
2976                 sym_op->cipher.data.offset = cipher_offset;
2977         } else {
2978                 sym_op->cipher.data.length = cipher_len >> 3;
2979                 sym_op->cipher.data.offset = cipher_offset >> 3;
2980         }
2981
2982         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2983                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2984                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2985                 sym_op->auth.data.length = auth_len;
2986                 sym_op->auth.data.offset = auth_offset;
2987         } else {
2988                 sym_op->auth.data.length = auth_len >> 3;
2989                 sym_op->auth.data.offset = auth_offset >> 3;
2990         }
2991
2992         return 0;
2993 }
2994
2995 static int
2996 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2997 {
2998         struct crypto_testsuite_params *ts_params = &testsuite_params;
2999         struct crypto_unittest_params *ut_params = &unittest_params;
3000
3001         int retval;
3002         unsigned plaintext_pad_len;
3003         unsigned plaintext_len;
3004         uint8_t *plaintext;
3005         struct rte_cryptodev_info dev_info;
3006
3007         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3008         uint64_t feat_flags = dev_info.feature_flags;
3009
3010         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3011                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3012                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3013                 return TEST_SKIPPED;
3014         }
3015
3016         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3017                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3018                 printf("Device doesn't support RAW data-path APIs.\n");
3019                 return TEST_SKIPPED;
3020         }
3021
3022         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3023                 return TEST_SKIPPED;
3024
3025         /* Verify the capabilities */
3026         struct rte_cryptodev_sym_capability_idx cap_idx;
3027         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3028         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3029         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3030                         &cap_idx) == NULL)
3031                 return TEST_SKIPPED;
3032
3033         /* Create SNOW 3G session */
3034         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3035                         tdata->key.data, tdata->key.len,
3036                         tdata->auth_iv.len, tdata->digest.len,
3037                         RTE_CRYPTO_AUTH_OP_GENERATE,
3038                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3039         if (retval < 0)
3040                 return retval;
3041
3042         /* alloc mbuf and set payload */
3043         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3044
3045         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3046         rte_pktmbuf_tailroom(ut_params->ibuf));
3047
3048         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3049         /* Append data which is padded to a multiple of */
3050         /* the algorithms block size */
3051         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3052         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3053                                 plaintext_pad_len);
3054         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3055
3056         /* Create SNOW 3G operation */
3057         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3058                         tdata->auth_iv.data, tdata->auth_iv.len,
3059                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3060                         tdata->validAuthLenInBits.len,
3061                         0);
3062         if (retval < 0)
3063                 return retval;
3064
3065         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3066                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3067                                 ut_params->op, 0, 1, 1, 0);
3068         else
3069                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3070                                 ut_params->op);
3071         ut_params->obuf = ut_params->op->sym->m_src;
3072         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3073         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3074                         + plaintext_pad_len;
3075
3076         /* Validate obuf */
3077         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3078         ut_params->digest,
3079         tdata->digest.data,
3080         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3081         "SNOW 3G Generated auth tag not as expected");
3082
3083         return 0;
3084 }
3085
3086 static int
3087 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3088 {
3089         struct crypto_testsuite_params *ts_params = &testsuite_params;
3090         struct crypto_unittest_params *ut_params = &unittest_params;
3091
3092         int retval;
3093         unsigned plaintext_pad_len;
3094         unsigned plaintext_len;
3095         uint8_t *plaintext;
3096         struct rte_cryptodev_info dev_info;
3097
3098         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3099         uint64_t feat_flags = dev_info.feature_flags;
3100
3101         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3102                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3103                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3104                 return TEST_SKIPPED;
3105         }
3106
3107         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3108                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3109                 printf("Device doesn't support RAW data-path APIs.\n");
3110                 return TEST_SKIPPED;
3111         }
3112
3113         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3114                 return TEST_SKIPPED;
3115
3116         /* Verify the capabilities */
3117         struct rte_cryptodev_sym_capability_idx cap_idx;
3118         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3119         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3120         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3121                         &cap_idx) == NULL)
3122                 return TEST_SKIPPED;
3123
3124         /* Create SNOW 3G session */
3125         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3126                                 tdata->key.data, tdata->key.len,
3127                                 tdata->auth_iv.len, tdata->digest.len,
3128                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3129                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3130         if (retval < 0)
3131                 return retval;
3132         /* alloc mbuf and set payload */
3133         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3134
3135         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3136         rte_pktmbuf_tailroom(ut_params->ibuf));
3137
3138         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3139         /* Append data which is padded to a multiple of */
3140         /* the algorithms block size */
3141         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3142         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3143                                 plaintext_pad_len);
3144         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3145
3146         /* Create SNOW 3G operation */
3147         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3148                         tdata->digest.len,
3149                         tdata->auth_iv.data, tdata->auth_iv.len,
3150                         plaintext_pad_len,
3151                         RTE_CRYPTO_AUTH_OP_VERIFY,
3152                         tdata->validAuthLenInBits.len,
3153                         0);
3154         if (retval < 0)
3155                 return retval;
3156
3157         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3158                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3159                                 ut_params->op, 0, 1, 1, 0);
3160         else
3161                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3162                                 ut_params->op);
3163         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3164         ut_params->obuf = ut_params->op->sym->m_src;
3165         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3166                                 + plaintext_pad_len;
3167
3168         /* Validate obuf */
3169         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3170                 return 0;
3171         else
3172                 return -1;
3173
3174         return 0;
3175 }
3176
3177 static int
3178 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3179 {
3180         struct crypto_testsuite_params *ts_params = &testsuite_params;
3181         struct crypto_unittest_params *ut_params = &unittest_params;
3182
3183         int retval;
3184         unsigned plaintext_pad_len;
3185         unsigned plaintext_len;
3186         uint8_t *plaintext;
3187         struct rte_cryptodev_info dev_info;
3188
3189         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3190         uint64_t feat_flags = dev_info.feature_flags;
3191
3192         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3193                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3194                 printf("Device doesn't support RAW data-path APIs.\n");
3195                 return TEST_SKIPPED;
3196         }
3197
3198         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3199                 return TEST_SKIPPED;
3200
3201         /* Verify the capabilities */
3202         struct rte_cryptodev_sym_capability_idx cap_idx;
3203         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3204         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3205         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3206                         &cap_idx) == NULL)
3207                 return TEST_SKIPPED;
3208
3209         /* Create KASUMI session */
3210         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3211                         tdata->key.data, tdata->key.len,
3212                         0, tdata->digest.len,
3213                         RTE_CRYPTO_AUTH_OP_GENERATE,
3214                         RTE_CRYPTO_AUTH_KASUMI_F9);
3215         if (retval < 0)
3216                 return retval;
3217
3218         /* alloc mbuf and set payload */
3219         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3220
3221         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3222         rte_pktmbuf_tailroom(ut_params->ibuf));
3223
3224         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3225         /* Append data which is padded to a multiple of */
3226         /* the algorithms block size */
3227         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3228         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3229                                 plaintext_pad_len);
3230         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3231
3232         /* Create KASUMI operation */
3233         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3234                         NULL, 0,
3235                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3236                         tdata->plaintext.len,
3237                         0);
3238         if (retval < 0)
3239                 return retval;
3240
3241         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3242                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3243                         ut_params->op);
3244         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3245                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3246                                 ut_params->op, 0, 1, 1, 0);
3247         else
3248                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3249                         ut_params->op);
3250
3251         ut_params->obuf = ut_params->op->sym->m_src;
3252         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3253         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3254                         + plaintext_pad_len;
3255
3256         /* Validate obuf */
3257         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3258         ut_params->digest,
3259         tdata->digest.data,
3260         DIGEST_BYTE_LENGTH_KASUMI_F9,
3261         "KASUMI Generated auth tag not as expected");
3262
3263         return 0;
3264 }
3265
3266 static int
3267 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3268 {
3269         struct crypto_testsuite_params *ts_params = &testsuite_params;
3270         struct crypto_unittest_params *ut_params = &unittest_params;
3271
3272         int retval;
3273         unsigned plaintext_pad_len;
3274         unsigned plaintext_len;
3275         uint8_t *plaintext;
3276         struct rte_cryptodev_info dev_info;
3277
3278         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3279         uint64_t feat_flags = dev_info.feature_flags;
3280
3281         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3282                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3283                 printf("Device doesn't support RAW data-path APIs.\n");
3284                 return TEST_SKIPPED;
3285         }
3286
3287         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3288                 return TEST_SKIPPED;
3289
3290         /* Verify the capabilities */
3291         struct rte_cryptodev_sym_capability_idx cap_idx;
3292         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3293         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3294         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3295                         &cap_idx) == NULL)
3296                 return TEST_SKIPPED;
3297
3298         /* Create KASUMI session */
3299         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3300                                 tdata->key.data, tdata->key.len,
3301                                 0, tdata->digest.len,
3302                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3303                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3304         if (retval < 0)
3305                 return retval;
3306         /* alloc mbuf and set payload */
3307         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3308
3309         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3310         rte_pktmbuf_tailroom(ut_params->ibuf));
3311
3312         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3313         /* Append data which is padded to a multiple */
3314         /* of the algorithms block size */
3315         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3316         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3317                                 plaintext_pad_len);
3318         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3319
3320         /* Create KASUMI operation */
3321         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3322                         tdata->digest.len,
3323                         NULL, 0,
3324                         plaintext_pad_len,
3325                         RTE_CRYPTO_AUTH_OP_VERIFY,
3326                         tdata->plaintext.len,
3327                         0);
3328         if (retval < 0)
3329                 return retval;
3330
3331         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3332                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3333                                 ut_params->op, 0, 1, 1, 0);
3334         else
3335                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3336                                 ut_params->op);
3337         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3338         ut_params->obuf = ut_params->op->sym->m_src;
3339         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3340                                 + plaintext_pad_len;
3341
3342         /* Validate obuf */
3343         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3344                 return 0;
3345         else
3346                 return -1;
3347
3348         return 0;
3349 }
3350
3351 static int
3352 test_snow3g_hash_generate_test_case_1(void)
3353 {
3354         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3355 }
3356
3357 static int
3358 test_snow3g_hash_generate_test_case_2(void)
3359 {
3360         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3361 }
3362
3363 static int
3364 test_snow3g_hash_generate_test_case_3(void)
3365 {
3366         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3367 }
3368
3369 static int
3370 test_snow3g_hash_generate_test_case_4(void)
3371 {
3372         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3373 }
3374
3375 static int
3376 test_snow3g_hash_generate_test_case_5(void)
3377 {
3378         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3379 }
3380
3381 static int
3382 test_snow3g_hash_generate_test_case_6(void)
3383 {
3384         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3385 }
3386
3387 static int
3388 test_snow3g_hash_verify_test_case_1(void)
3389 {
3390         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3391
3392 }
3393
3394 static int
3395 test_snow3g_hash_verify_test_case_2(void)
3396 {
3397         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3398 }
3399
3400 static int
3401 test_snow3g_hash_verify_test_case_3(void)
3402 {
3403         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3404 }
3405
3406 static int
3407 test_snow3g_hash_verify_test_case_4(void)
3408 {
3409         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3410 }
3411
3412 static int
3413 test_snow3g_hash_verify_test_case_5(void)
3414 {
3415         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3416 }
3417
3418 static int
3419 test_snow3g_hash_verify_test_case_6(void)
3420 {
3421         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3422 }
3423
3424 static int
3425 test_kasumi_hash_generate_test_case_1(void)
3426 {
3427         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3428 }
3429
3430 static int
3431 test_kasumi_hash_generate_test_case_2(void)
3432 {
3433         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3434 }
3435
3436 static int
3437 test_kasumi_hash_generate_test_case_3(void)
3438 {
3439         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3440 }
3441
3442 static int
3443 test_kasumi_hash_generate_test_case_4(void)
3444 {
3445         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3446 }
3447
3448 static int
3449 test_kasumi_hash_generate_test_case_5(void)
3450 {
3451         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3452 }
3453
3454 static int
3455 test_kasumi_hash_generate_test_case_6(void)
3456 {
3457         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3458 }
3459
3460 static int
3461 test_kasumi_hash_verify_test_case_1(void)
3462 {
3463         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3464 }
3465
3466 static int
3467 test_kasumi_hash_verify_test_case_2(void)
3468 {
3469         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3470 }
3471
3472 static int
3473 test_kasumi_hash_verify_test_case_3(void)
3474 {
3475         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3476 }
3477
3478 static int
3479 test_kasumi_hash_verify_test_case_4(void)
3480 {
3481         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3482 }
3483
3484 static int
3485 test_kasumi_hash_verify_test_case_5(void)
3486 {
3487         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3488 }
3489
3490 static int
3491 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3492 {
3493         struct crypto_testsuite_params *ts_params = &testsuite_params;
3494         struct crypto_unittest_params *ut_params = &unittest_params;
3495
3496         int retval;
3497         uint8_t *plaintext, *ciphertext;
3498         unsigned plaintext_pad_len;
3499         unsigned plaintext_len;
3500         struct rte_cryptodev_info dev_info;
3501
3502         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3503         uint64_t feat_flags = dev_info.feature_flags;
3504
3505         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3506                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3507                 printf("Device doesn't support RAW data-path APIs.\n");
3508                 return TEST_SKIPPED;
3509         }
3510
3511         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3512                 return TEST_SKIPPED;
3513
3514         /* Verify the capabilities */
3515         struct rte_cryptodev_sym_capability_idx cap_idx;
3516         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3517         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3518         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3519                         &cap_idx) == NULL)
3520                 return TEST_SKIPPED;
3521
3522         /* Create KASUMI session */
3523         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3524                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3525                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3526                                         tdata->key.data, tdata->key.len,
3527                                         tdata->cipher_iv.len);
3528         if (retval < 0)
3529                 return retval;
3530
3531         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3532
3533         /* Clear mbuf payload */
3534         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3535                rte_pktmbuf_tailroom(ut_params->ibuf));
3536
3537         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3538         /* Append data which is padded to a multiple */
3539         /* of the algorithms block size */
3540         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3541         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3542                                 plaintext_pad_len);
3543         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3544
3545         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3546
3547         /* Create KASUMI operation */
3548         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3549                                 tdata->cipher_iv.len,
3550                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3551                                 tdata->validCipherOffsetInBits.len);
3552         if (retval < 0)
3553                 return retval;
3554
3555         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3556                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3557                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3558         else
3559                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3560                                 ut_params->op);
3561         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3562
3563         ut_params->obuf = ut_params->op->sym->m_dst;
3564         if (ut_params->obuf)
3565                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3566         else
3567                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3568
3569         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3570
3571         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3572                                 (tdata->validCipherOffsetInBits.len >> 3);
3573         /* Validate obuf */
3574         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3575                 ciphertext,
3576                 reference_ciphertext,
3577                 tdata->validCipherLenInBits.len,
3578                 "KASUMI Ciphertext data not as expected");
3579         return 0;
3580 }
3581
3582 static int
3583 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3584 {
3585         struct crypto_testsuite_params *ts_params = &testsuite_params;
3586         struct crypto_unittest_params *ut_params = &unittest_params;
3587
3588         int retval;
3589
3590         unsigned int plaintext_pad_len;
3591         unsigned int plaintext_len;
3592
3593         uint8_t buffer[10000];
3594         const uint8_t *ciphertext;
3595
3596         struct rte_cryptodev_info dev_info;
3597
3598         /* Verify the capabilities */
3599         struct rte_cryptodev_sym_capability_idx cap_idx;
3600         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3601         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3602         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3603                         &cap_idx) == NULL)
3604                 return TEST_SKIPPED;
3605
3606         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3607
3608         uint64_t feat_flags = dev_info.feature_flags;
3609
3610         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3611                 printf("Device doesn't support in-place scatter-gather. "
3612                                 "Test Skipped.\n");
3613                 return TEST_SKIPPED;
3614         }
3615
3616         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3617                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3618                 printf("Device doesn't support RAW data-path APIs.\n");
3619                 return TEST_SKIPPED;
3620         }
3621
3622         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3623                 return TEST_SKIPPED;
3624
3625         /* Create KASUMI session */
3626         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3627                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3628                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3629                                         tdata->key.data, tdata->key.len,
3630                                         tdata->cipher_iv.len);
3631         if (retval < 0)
3632                 return retval;
3633
3634         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3635
3636
3637         /* Append data which is padded to a multiple */
3638         /* of the algorithms block size */
3639         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3640
3641         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3642                         plaintext_pad_len, 10, 0);
3643
3644         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3645
3646         /* Create KASUMI operation */
3647         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3648                                 tdata->cipher_iv.len,
3649                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3650                                 tdata->validCipherOffsetInBits.len);
3651         if (retval < 0)
3652                 return retval;
3653
3654         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3655                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3656                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3657         else
3658                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3659                                                 ut_params->op);
3660         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3661
3662         ut_params->obuf = ut_params->op->sym->m_dst;
3663
3664         if (ut_params->obuf)
3665                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3666                                 plaintext_len, buffer);
3667         else
3668                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3669                                 tdata->validCipherOffsetInBits.len >> 3,
3670                                 plaintext_len, buffer);
3671
3672         /* Validate obuf */
3673         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3674
3675         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3676                                 (tdata->validCipherOffsetInBits.len >> 3);
3677         /* Validate obuf */
3678         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3679                 ciphertext,
3680                 reference_ciphertext,
3681                 tdata->validCipherLenInBits.len,
3682                 "KASUMI Ciphertext data not as expected");
3683         return 0;
3684 }
3685
3686 static int
3687 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3688 {
3689         struct crypto_testsuite_params *ts_params = &testsuite_params;
3690         struct crypto_unittest_params *ut_params = &unittest_params;
3691
3692         int retval;
3693         uint8_t *plaintext, *ciphertext;
3694         unsigned plaintext_pad_len;
3695         unsigned plaintext_len;
3696
3697         /* Verify the capabilities */
3698         struct rte_cryptodev_sym_capability_idx cap_idx;
3699         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3700         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3701         /* Data-path service does not support OOP */
3702         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3703                         &cap_idx) == NULL)
3704                 return TEST_SKIPPED;
3705
3706         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3707                 return TEST_SKIPPED;
3708
3709         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3710                 return TEST_SKIPPED;
3711
3712         /* Create KASUMI session */
3713         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3714                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3715                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
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         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3723
3724         /* Clear mbuf payload */
3725         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3726                rte_pktmbuf_tailroom(ut_params->ibuf));
3727
3728         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3729         /* Append data which is padded to a multiple */
3730         /* of the algorithms block size */
3731         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3732         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3733                                 plaintext_pad_len);
3734         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3735         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3736
3737         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3738
3739         /* Create KASUMI operation */
3740         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3741                                 tdata->cipher_iv.len,
3742                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3743                                 tdata->validCipherOffsetInBits.len);
3744         if (retval < 0)
3745                 return retval;
3746
3747         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3748                                                 ut_params->op);
3749         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3750
3751         ut_params->obuf = ut_params->op->sym->m_dst;
3752         if (ut_params->obuf)
3753                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3754         else
3755                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3756
3757         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3758
3759         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3760                                 (tdata->validCipherOffsetInBits.len >> 3);
3761         /* Validate obuf */
3762         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3763                 ciphertext,
3764                 reference_ciphertext,
3765                 tdata->validCipherLenInBits.len,
3766                 "KASUMI Ciphertext data not as expected");
3767         return 0;
3768 }
3769
3770 static int
3771 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3772 {
3773         struct crypto_testsuite_params *ts_params = &testsuite_params;
3774         struct crypto_unittest_params *ut_params = &unittest_params;
3775
3776         int retval;
3777         unsigned int plaintext_pad_len;
3778         unsigned int plaintext_len;
3779
3780         const uint8_t *ciphertext;
3781         uint8_t buffer[2048];
3782
3783         struct rte_cryptodev_info dev_info;
3784
3785         /* Verify the capabilities */
3786         struct rte_cryptodev_sym_capability_idx cap_idx;
3787         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3788         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3789         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3790                         &cap_idx) == NULL)
3791                 return TEST_SKIPPED;
3792
3793         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3794                 return TEST_SKIPPED;
3795
3796         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3797                 return TEST_SKIPPED;
3798
3799         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3800
3801         uint64_t feat_flags = dev_info.feature_flags;
3802         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3803                 printf("Device doesn't support out-of-place scatter-gather "
3804                                 "in both input and output mbufs. "
3805                                 "Test Skipped.\n");
3806                 return TEST_SKIPPED;
3807         }
3808
3809         /* Create KASUMI session */
3810         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3811                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3812                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3813                                         tdata->key.data, tdata->key.len,
3814                                         tdata->cipher_iv.len);
3815         if (retval < 0)
3816                 return retval;
3817
3818         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3819         /* Append data which is padded to a multiple */
3820         /* of the algorithms block size */
3821         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3822
3823         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3824                         plaintext_pad_len, 10, 0);
3825         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3826                         plaintext_pad_len, 3, 0);
3827
3828         /* Append data which is padded to a multiple */
3829         /* of the algorithms block size */
3830         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3831
3832         /* Create KASUMI operation */
3833         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3834                                 tdata->cipher_iv.len,
3835                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3836                                 tdata->validCipherOffsetInBits.len);
3837         if (retval < 0)
3838                 return retval;
3839
3840         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3841                                                 ut_params->op);
3842         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3843
3844         ut_params->obuf = ut_params->op->sym->m_dst;
3845         if (ut_params->obuf)
3846                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3847                                 plaintext_pad_len, buffer);
3848         else
3849                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3850                                 tdata->validCipherOffsetInBits.len >> 3,
3851                                 plaintext_pad_len, buffer);
3852
3853         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3854                                 (tdata->validCipherOffsetInBits.len >> 3);
3855         /* Validate obuf */
3856         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3857                 ciphertext,
3858                 reference_ciphertext,
3859                 tdata->validCipherLenInBits.len,
3860                 "KASUMI Ciphertext data not as expected");
3861         return 0;
3862 }
3863
3864
3865 static int
3866 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3867 {
3868         struct crypto_testsuite_params *ts_params = &testsuite_params;
3869         struct crypto_unittest_params *ut_params = &unittest_params;
3870
3871         int retval;
3872         uint8_t *ciphertext, *plaintext;
3873         unsigned ciphertext_pad_len;
3874         unsigned ciphertext_len;
3875
3876         /* Verify the capabilities */
3877         struct rte_cryptodev_sym_capability_idx cap_idx;
3878         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3879         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3880         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3881                         &cap_idx) == NULL)
3882                 return TEST_SKIPPED;
3883
3884         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3885                 return TEST_SKIPPED;
3886
3887         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3888                 return TEST_SKIPPED;
3889
3890         /* Create KASUMI session */
3891         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3892                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3893                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3894                                         tdata->key.data, tdata->key.len,
3895                                         tdata->cipher_iv.len);
3896         if (retval < 0)
3897                 return retval;
3898
3899         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3900         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3901
3902         /* Clear mbuf payload */
3903         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3904                rte_pktmbuf_tailroom(ut_params->ibuf));
3905
3906         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3907         /* Append data which is padded to a multiple */
3908         /* of the algorithms block size */
3909         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3910         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3911                                 ciphertext_pad_len);
3912         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3913         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3914
3915         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3916
3917         /* Create KASUMI operation */
3918         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3919                                 tdata->cipher_iv.len,
3920                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3921                                 tdata->validCipherOffsetInBits.len);
3922         if (retval < 0)
3923                 return retval;
3924
3925         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3926                                                 ut_params->op);
3927         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3928
3929         ut_params->obuf = ut_params->op->sym->m_dst;
3930         if (ut_params->obuf)
3931                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3932         else
3933                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3934
3935         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3936
3937         const uint8_t *reference_plaintext = tdata->plaintext.data +
3938                                 (tdata->validCipherOffsetInBits.len >> 3);
3939         /* Validate obuf */
3940         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3941                 plaintext,
3942                 reference_plaintext,
3943                 tdata->validCipherLenInBits.len,
3944                 "KASUMI Plaintext data not as expected");
3945         return 0;
3946 }
3947
3948 static int
3949 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3950 {
3951         struct crypto_testsuite_params *ts_params = &testsuite_params;
3952         struct crypto_unittest_params *ut_params = &unittest_params;
3953
3954         int retval;
3955         uint8_t *ciphertext, *plaintext;
3956         unsigned ciphertext_pad_len;
3957         unsigned ciphertext_len;
3958         struct rte_cryptodev_info dev_info;
3959
3960         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3961         uint64_t feat_flags = dev_info.feature_flags;
3962
3963         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3964                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3965                 printf("Device doesn't support RAW data-path APIs.\n");
3966                 return TEST_SKIPPED;
3967         }
3968
3969         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3970                 return TEST_SKIPPED;
3971
3972         /* Verify the capabilities */
3973         struct rte_cryptodev_sym_capability_idx cap_idx;
3974         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3975         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3976         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3977                         &cap_idx) == NULL)
3978                 return TEST_SKIPPED;
3979
3980         /* Create KASUMI session */
3981         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3982                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3983                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3984                                         tdata->key.data, tdata->key.len,
3985                                         tdata->cipher_iv.len);
3986         if (retval < 0)
3987                 return retval;
3988
3989         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3990
3991         /* Clear mbuf payload */
3992         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3993                rte_pktmbuf_tailroom(ut_params->ibuf));
3994
3995         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3996         /* Append data which is padded to a multiple */
3997         /* of the algorithms block size */
3998         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3999         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4000                                 ciphertext_pad_len);
4001         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4002
4003         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4004
4005         /* Create KASUMI operation */
4006         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4007                                         tdata->cipher_iv.len,
4008                                         tdata->ciphertext.len,
4009                                         tdata->validCipherOffsetInBits.len);
4010         if (retval < 0)
4011                 return retval;
4012
4013         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4014                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4015                                 ut_params->op, 1, 0, 1, 0);
4016         else
4017                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4018                                                 ut_params->op);
4019         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4020
4021         ut_params->obuf = ut_params->op->sym->m_dst;
4022         if (ut_params->obuf)
4023                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4024         else
4025                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4026
4027         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4028
4029         const uint8_t *reference_plaintext = tdata->plaintext.data +
4030                                 (tdata->validCipherOffsetInBits.len >> 3);
4031         /* Validate obuf */
4032         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4033                 plaintext,
4034                 reference_plaintext,
4035                 tdata->validCipherLenInBits.len,
4036                 "KASUMI Plaintext data not as expected");
4037         return 0;
4038 }
4039
4040 static int
4041 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4042 {
4043         struct crypto_testsuite_params *ts_params = &testsuite_params;
4044         struct crypto_unittest_params *ut_params = &unittest_params;
4045
4046         int retval;
4047         uint8_t *plaintext, *ciphertext;
4048         unsigned plaintext_pad_len;
4049         unsigned plaintext_len;
4050         struct rte_cryptodev_info dev_info;
4051
4052         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4053         uint64_t feat_flags = dev_info.feature_flags;
4054
4055         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4056                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4057                 printf("Device doesn't support RAW data-path APIs.\n");
4058                 return TEST_SKIPPED;
4059         }
4060
4061         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4062                 return TEST_SKIPPED;
4063
4064         /* Verify the capabilities */
4065         struct rte_cryptodev_sym_capability_idx cap_idx;
4066         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4067         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4068         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4069                         &cap_idx) == NULL)
4070                 return TEST_SKIPPED;
4071
4072         /* Create SNOW 3G session */
4073         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4074                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4075                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4076                                         tdata->key.data, tdata->key.len,
4077                                         tdata->cipher_iv.len);
4078         if (retval < 0)
4079                 return retval;
4080
4081         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4082
4083         /* Clear mbuf payload */
4084         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4085                rte_pktmbuf_tailroom(ut_params->ibuf));
4086
4087         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4088         /* Append data which is padded to a multiple of */
4089         /* the algorithms block size */
4090         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4091         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4092                                 plaintext_pad_len);
4093         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4094
4095         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4096
4097         /* Create SNOW 3G operation */
4098         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4099                                         tdata->cipher_iv.len,
4100                                         tdata->validCipherLenInBits.len,
4101                                         0);
4102         if (retval < 0)
4103                 return retval;
4104
4105         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4106                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4107                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4108         else
4109                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4110                                                 ut_params->op);
4111         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4112
4113         ut_params->obuf = ut_params->op->sym->m_dst;
4114         if (ut_params->obuf)
4115                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4116         else
4117                 ciphertext = plaintext;
4118
4119         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4120
4121         /* Validate obuf */
4122         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4123                 ciphertext,
4124                 tdata->ciphertext.data,
4125                 tdata->validDataLenInBits.len,
4126                 "SNOW 3G Ciphertext data not as expected");
4127         return 0;
4128 }
4129
4130
4131 static int
4132 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4133 {
4134         struct crypto_testsuite_params *ts_params = &testsuite_params;
4135         struct crypto_unittest_params *ut_params = &unittest_params;
4136         uint8_t *plaintext, *ciphertext;
4137
4138         int retval;
4139         unsigned plaintext_pad_len;
4140         unsigned plaintext_len;
4141
4142         /* Verify the capabilities */
4143         struct rte_cryptodev_sym_capability_idx cap_idx;
4144         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4145         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4146         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4147                         &cap_idx) == NULL)
4148                 return TEST_SKIPPED;
4149
4150         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4151                 return TEST_SKIPPED;
4152
4153         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4154                 return TEST_SKIPPED;
4155
4156         /* Create SNOW 3G session */
4157         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4158                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4159                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4160                                         tdata->key.data, tdata->key.len,
4161                                         tdata->cipher_iv.len);
4162         if (retval < 0)
4163                 return retval;
4164
4165         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4166         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4167
4168         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4169                         "Failed to allocate input buffer in mempool");
4170         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4171                         "Failed to allocate output buffer in mempool");
4172
4173         /* Clear mbuf payload */
4174         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4175                rte_pktmbuf_tailroom(ut_params->ibuf));
4176
4177         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4178         /* Append data which is padded to a multiple of */
4179         /* the algorithms block size */
4180         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4181         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4182                                 plaintext_pad_len);
4183         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4184         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4185
4186         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4187
4188         /* Create SNOW 3G operation */
4189         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4190                                         tdata->cipher_iv.len,
4191                                         tdata->validCipherLenInBits.len,
4192                                         0);
4193         if (retval < 0)
4194                 return retval;
4195
4196         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4197                                                 ut_params->op);
4198         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4199
4200         ut_params->obuf = ut_params->op->sym->m_dst;
4201         if (ut_params->obuf)
4202                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4203         else
4204                 ciphertext = plaintext;
4205
4206         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4207
4208         /* Validate obuf */
4209         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4210                 ciphertext,
4211                 tdata->ciphertext.data,
4212                 tdata->validDataLenInBits.len,
4213                 "SNOW 3G Ciphertext data not as expected");
4214         return 0;
4215 }
4216
4217 static int
4218 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4219 {
4220         struct crypto_testsuite_params *ts_params = &testsuite_params;
4221         struct crypto_unittest_params *ut_params = &unittest_params;
4222
4223         int retval;
4224         unsigned int plaintext_pad_len;
4225         unsigned int plaintext_len;
4226         uint8_t buffer[10000];
4227         const uint8_t *ciphertext;
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_CIPHER;
4234         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4235         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4236                         &cap_idx) == NULL)
4237                 return TEST_SKIPPED;
4238
4239         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4240                 return TEST_SKIPPED;
4241
4242         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4243                 return TEST_SKIPPED;
4244
4245         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4246
4247         uint64_t feat_flags = dev_info.feature_flags;
4248
4249         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4250                 printf("Device doesn't support out-of-place scatter-gather "
4251                                 "in both input and output mbufs. "
4252                                 "Test Skipped.\n");
4253                 return TEST_SKIPPED;
4254         }
4255
4256         /* Create SNOW 3G session */
4257         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4258                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4259                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4260                                         tdata->key.data, tdata->key.len,
4261                                         tdata->cipher_iv.len);
4262         if (retval < 0)
4263                 return retval;
4264
4265         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4266         /* Append data which is padded to a multiple of */
4267         /* the algorithms block size */
4268         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4269
4270         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4271                         plaintext_pad_len, 10, 0);
4272         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4273                         plaintext_pad_len, 3, 0);
4274
4275         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4276                         "Failed to allocate input buffer in mempool");
4277         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4278                         "Failed to allocate output buffer in mempool");
4279
4280         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4281
4282         /* Create SNOW 3G operation */
4283         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4284                                         tdata->cipher_iv.len,
4285                                         tdata->validCipherLenInBits.len,
4286                                         0);
4287         if (retval < 0)
4288                 return retval;
4289
4290         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4291                                                 ut_params->op);
4292         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4293
4294         ut_params->obuf = ut_params->op->sym->m_dst;
4295         if (ut_params->obuf)
4296                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4297                                 plaintext_len, buffer);
4298         else
4299                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4300                                 plaintext_len, buffer);
4301
4302         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4303
4304         /* Validate obuf */
4305         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4306                 ciphertext,
4307                 tdata->ciphertext.data,
4308                 tdata->validDataLenInBits.len,
4309                 "SNOW 3G Ciphertext data not as expected");
4310
4311         return 0;
4312 }
4313
4314 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4315 static void
4316 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4317 {
4318         uint8_t curr_byte, prev_byte;
4319         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4320         uint8_t lower_byte_mask = (1 << offset) - 1;
4321         unsigned i;
4322
4323         prev_byte = buffer[0];
4324         buffer[0] >>= offset;
4325
4326         for (i = 1; i < length_in_bytes; i++) {
4327                 curr_byte = buffer[i];
4328                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4329                                 (curr_byte >> offset);
4330                 prev_byte = curr_byte;
4331         }
4332 }
4333
4334 static int
4335 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4336 {
4337         struct crypto_testsuite_params *ts_params = &testsuite_params;
4338         struct crypto_unittest_params *ut_params = &unittest_params;
4339         uint8_t *plaintext, *ciphertext;
4340         int retval;
4341         uint32_t plaintext_len;
4342         uint32_t plaintext_pad_len;
4343         uint8_t extra_offset = 4;
4344         uint8_t *expected_ciphertext_shifted;
4345         struct rte_cryptodev_info dev_info;
4346
4347         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4348         uint64_t feat_flags = dev_info.feature_flags;
4349
4350         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4351                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4352                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4353                 return TEST_SKIPPED;
4354         }
4355
4356         /* Verify the capabilities */
4357         struct rte_cryptodev_sym_capability_idx cap_idx;
4358         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4359         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4360         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4361                         &cap_idx) == NULL)
4362                 return TEST_SKIPPED;
4363
4364         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4365                 return TEST_SKIPPED;
4366
4367         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4368                 return TEST_SKIPPED;
4369
4370         /* Create SNOW 3G session */
4371         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4372                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4373                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4374                                         tdata->key.data, tdata->key.len,
4375                                         tdata->cipher_iv.len);
4376         if (retval < 0)
4377                 return retval;
4378
4379         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4380         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4381
4382         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4383                         "Failed to allocate input buffer in mempool");
4384         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4385                         "Failed to allocate output buffer in mempool");
4386
4387         /* Clear mbuf payload */
4388         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4389                rte_pktmbuf_tailroom(ut_params->ibuf));
4390
4391         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4392         /*
4393          * Append data which is padded to a
4394          * multiple of the algorithms block size
4395          */
4396         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4397
4398         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4399                                                 plaintext_pad_len);
4400
4401         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4402
4403         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4404         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4405
4406 #ifdef RTE_APP_TEST_DEBUG
4407         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4408 #endif
4409         /* Create SNOW 3G operation */
4410         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4411                                         tdata->cipher_iv.len,
4412                                         tdata->validCipherLenInBits.len,
4413                                         extra_offset);
4414         if (retval < 0)
4415                 return retval;
4416
4417         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4418                                                 ut_params->op);
4419         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4420
4421         ut_params->obuf = ut_params->op->sym->m_dst;
4422         if (ut_params->obuf)
4423                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4424         else
4425                 ciphertext = plaintext;
4426
4427 #ifdef RTE_APP_TEST_DEBUG
4428         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4429 #endif
4430
4431         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4432
4433         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4434                         "failed to reserve memory for ciphertext shifted\n");
4435
4436         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4437                         ceil_byte_length(tdata->ciphertext.len));
4438         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4439                         extra_offset);
4440         /* Validate obuf */
4441         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4442                 ciphertext,
4443                 expected_ciphertext_shifted,
4444                 tdata->validDataLenInBits.len,
4445                 extra_offset,
4446                 "SNOW 3G Ciphertext data not as expected");
4447         return 0;
4448 }
4449
4450 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4451 {
4452         struct crypto_testsuite_params *ts_params = &testsuite_params;
4453         struct crypto_unittest_params *ut_params = &unittest_params;
4454
4455         int retval;
4456
4457         uint8_t *plaintext, *ciphertext;
4458         unsigned ciphertext_pad_len;
4459         unsigned ciphertext_len;
4460         struct rte_cryptodev_info dev_info;
4461
4462         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4463         uint64_t feat_flags = dev_info.feature_flags;
4464
4465         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4466                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4467                 printf("Device doesn't support RAW data-path APIs.\n");
4468                 return TEST_SKIPPED;
4469         }
4470
4471         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4472                 return TEST_SKIPPED;
4473
4474         /* Verify the capabilities */
4475         struct rte_cryptodev_sym_capability_idx cap_idx;
4476         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4477         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4478         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4479                         &cap_idx) == NULL)
4480                 return TEST_SKIPPED;
4481
4482         /* Create SNOW 3G session */
4483         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4484                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4485                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4486                                         tdata->key.data, tdata->key.len,
4487                                         tdata->cipher_iv.len);
4488         if (retval < 0)
4489                 return retval;
4490
4491         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4492
4493         /* Clear mbuf payload */
4494         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4495                rte_pktmbuf_tailroom(ut_params->ibuf));
4496
4497         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4498         /* Append data which is padded to a multiple of */
4499         /* the algorithms block size */
4500         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4501         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4502                                 ciphertext_pad_len);
4503         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4504
4505         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4506
4507         /* Create SNOW 3G operation */
4508         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4509                                         tdata->cipher_iv.len,
4510                                         tdata->validCipherLenInBits.len,
4511                                         tdata->cipher.offset_bits);
4512         if (retval < 0)
4513                 return retval;
4514
4515         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4516                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4517                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4518         else
4519                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4520                                                 ut_params->op);
4521         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4522         ut_params->obuf = ut_params->op->sym->m_dst;
4523         if (ut_params->obuf)
4524                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4525         else
4526                 plaintext = ciphertext;
4527
4528         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4529
4530         /* Validate obuf */
4531         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4532                                 tdata->plaintext.data,
4533                                 tdata->validDataLenInBits.len,
4534                                 "SNOW 3G Plaintext data not as expected");
4535         return 0;
4536 }
4537
4538 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4539 {
4540         struct crypto_testsuite_params *ts_params = &testsuite_params;
4541         struct crypto_unittest_params *ut_params = &unittest_params;
4542
4543         int retval;
4544
4545         uint8_t *plaintext, *ciphertext;
4546         unsigned ciphertext_pad_len;
4547         unsigned ciphertext_len;
4548
4549         /* Verify the capabilities */
4550         struct rte_cryptodev_sym_capability_idx cap_idx;
4551         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4552         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4553         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4554                         &cap_idx) == NULL)
4555                 return TEST_SKIPPED;
4556
4557         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4558                 return TEST_SKIPPED;
4559
4560         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4561                 return TEST_SKIPPED;
4562
4563         /* Create SNOW 3G session */
4564         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4565                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4566                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4567                                         tdata->key.data, tdata->key.len,
4568                                         tdata->cipher_iv.len);
4569         if (retval < 0)
4570                 return retval;
4571
4572         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4573         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4574
4575         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4576                         "Failed to allocate input buffer");
4577         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4578                         "Failed to allocate output buffer");
4579
4580         /* Clear mbuf payload */
4581         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4582                rte_pktmbuf_tailroom(ut_params->ibuf));
4583
4584         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4585                        rte_pktmbuf_tailroom(ut_params->obuf));
4586
4587         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4588         /* Append data which is padded to a multiple of */
4589         /* the algorithms block size */
4590         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4591         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4592                                 ciphertext_pad_len);
4593         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4594         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4595
4596         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4597
4598         /* Create SNOW 3G operation */
4599         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4600                                         tdata->cipher_iv.len,
4601                                         tdata->validCipherLenInBits.len,
4602                                         0);
4603         if (retval < 0)
4604                 return retval;
4605
4606         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4607                                                 ut_params->op);
4608         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4609         ut_params->obuf = ut_params->op->sym->m_dst;
4610         if (ut_params->obuf)
4611                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4612         else
4613                 plaintext = ciphertext;
4614
4615         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4616
4617         /* Validate obuf */
4618         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4619                                 tdata->plaintext.data,
4620                                 tdata->validDataLenInBits.len,
4621                                 "SNOW 3G Plaintext data not as expected");
4622         return 0;
4623 }
4624
4625 static int
4626 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4627 {
4628         struct crypto_testsuite_params *ts_params = &testsuite_params;
4629         struct crypto_unittest_params *ut_params = &unittest_params;
4630
4631         int retval;
4632
4633         uint8_t *plaintext, *ciphertext;
4634         unsigned int plaintext_pad_len;
4635         unsigned int plaintext_len;
4636
4637         struct rte_cryptodev_info dev_info;
4638         struct rte_cryptodev_sym_capability_idx cap_idx;
4639
4640         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4641         uint64_t feat_flags = dev_info.feature_flags;
4642
4643         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4644                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4645                         (tdata->validDataLenInBits.len % 8 != 0))) {
4646                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4647                 return TEST_SKIPPED;
4648         }
4649
4650         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4651                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4652                 printf("Device doesn't support RAW data-path APIs.\n");
4653                 return TEST_SKIPPED;
4654         }
4655
4656         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4657                 return TEST_SKIPPED;
4658
4659         /* Check if device supports ZUC EEA3 */
4660         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4661         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4662
4663         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4664                         &cap_idx) == NULL)
4665                 return TEST_SKIPPED;
4666
4667         /* Check if device supports ZUC EIA3 */
4668         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4669         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4670
4671         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4672                         &cap_idx) == NULL)
4673                 return TEST_SKIPPED;
4674
4675         /* Create ZUC session */
4676         retval = create_zuc_cipher_auth_encrypt_generate_session(
4677                         ts_params->valid_devs[0],
4678                         tdata);
4679         if (retval != 0)
4680                 return retval;
4681         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4682
4683         /* clear mbuf payload */
4684         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4685                         rte_pktmbuf_tailroom(ut_params->ibuf));
4686
4687         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4688         /* Append data which is padded to a multiple of */
4689         /* the algorithms block size */
4690         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4691         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4692                                 plaintext_pad_len);
4693         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4694
4695         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4696
4697         /* Create ZUC operation */
4698         retval = create_zuc_cipher_hash_generate_operation(tdata);
4699         if (retval < 0)
4700                 return retval;
4701
4702         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4703                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4704                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4705         else
4706                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4707                         ut_params->op);
4708         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4709         ut_params->obuf = ut_params->op->sym->m_src;
4710         if (ut_params->obuf)
4711                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4712         else
4713                 ciphertext = plaintext;
4714
4715         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4716         /* Validate obuf */
4717         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4718                         ciphertext,
4719                         tdata->ciphertext.data,
4720                         tdata->validDataLenInBits.len,
4721                         "ZUC Ciphertext data not as expected");
4722
4723         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4724             + plaintext_pad_len;
4725
4726         /* Validate obuf */
4727         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4728                         ut_params->digest,
4729                         tdata->digest.data,
4730                         4,
4731                         "ZUC Generated auth tag not as expected");
4732         return 0;
4733 }
4734
4735 static int
4736 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4737 {
4738         struct crypto_testsuite_params *ts_params = &testsuite_params;
4739         struct crypto_unittest_params *ut_params = &unittest_params;
4740
4741         int retval;
4742
4743         uint8_t *plaintext, *ciphertext;
4744         unsigned plaintext_pad_len;
4745         unsigned plaintext_len;
4746         struct rte_cryptodev_info dev_info;
4747
4748         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4749         uint64_t feat_flags = dev_info.feature_flags;
4750
4751         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4752                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4753                 printf("Device doesn't support RAW data-path APIs.\n");
4754                 return TEST_SKIPPED;
4755         }
4756
4757         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4758                 return TEST_SKIPPED;
4759
4760         /* Verify the capabilities */
4761         struct rte_cryptodev_sym_capability_idx cap_idx;
4762         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4763         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4764         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4765                         &cap_idx) == NULL)
4766                 return TEST_SKIPPED;
4767         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4768         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4769         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4770                         &cap_idx) == NULL)
4771                 return TEST_SKIPPED;
4772
4773         /* Create SNOW 3G session */
4774         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4775                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4776                         RTE_CRYPTO_AUTH_OP_GENERATE,
4777                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4778                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4779                         tdata->key.data, tdata->key.len,
4780                         tdata->auth_iv.len, tdata->digest.len,
4781                         tdata->cipher_iv.len);
4782         if (retval != 0)
4783                 return retval;
4784         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4785
4786         /* clear mbuf payload */
4787         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4788                         rte_pktmbuf_tailroom(ut_params->ibuf));
4789
4790         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4791         /* Append data which is padded to a multiple of */
4792         /* the algorithms block size */
4793         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4794         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4795                                 plaintext_pad_len);
4796         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4797
4798         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4799
4800         /* Create SNOW 3G operation */
4801         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4802                         tdata->digest.len, tdata->auth_iv.data,
4803                         tdata->auth_iv.len,
4804                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4805                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4806                         tdata->validCipherLenInBits.len,
4807                         0,
4808                         tdata->validAuthLenInBits.len,
4809                         0
4810                         );
4811         if (retval < 0)
4812                 return retval;
4813
4814         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4815                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4816                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4817         else
4818                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4819                         ut_params->op);
4820         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4821         ut_params->obuf = ut_params->op->sym->m_src;
4822         if (ut_params->obuf)
4823                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4824         else
4825                 ciphertext = plaintext;
4826
4827         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4828         /* Validate obuf */
4829         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4830                         ciphertext,
4831                         tdata->ciphertext.data,
4832                         tdata->validDataLenInBits.len,
4833                         "SNOW 3G Ciphertext data not as expected");
4834
4835         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4836             + plaintext_pad_len;
4837
4838         /* Validate obuf */
4839         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4840                         ut_params->digest,
4841                         tdata->digest.data,
4842                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4843                         "SNOW 3G Generated auth tag not as expected");
4844         return 0;
4845 }
4846
4847 static int
4848 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4849         uint8_t op_mode, uint8_t verify)
4850 {
4851         struct crypto_testsuite_params *ts_params = &testsuite_params;
4852         struct crypto_unittest_params *ut_params = &unittest_params;
4853
4854         int retval;
4855
4856         uint8_t *plaintext = NULL, *ciphertext = NULL;
4857         unsigned int plaintext_pad_len;
4858         unsigned int plaintext_len;
4859         unsigned int ciphertext_pad_len;
4860         unsigned int ciphertext_len;
4861
4862         struct rte_cryptodev_info dev_info;
4863
4864         /* Verify the capabilities */
4865         struct rte_cryptodev_sym_capability_idx cap_idx;
4866         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4867         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4868         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4869                         &cap_idx) == NULL)
4870                 return TEST_SKIPPED;
4871         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4872         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4873         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4874                         &cap_idx) == NULL)
4875                 return TEST_SKIPPED;
4876
4877         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4878                 return TEST_SKIPPED;
4879
4880         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4881
4882         uint64_t feat_flags = dev_info.feature_flags;
4883
4884         if (op_mode == OUT_OF_PLACE) {
4885                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4886                         printf("Device doesn't support digest encrypted.\n");
4887                         return TEST_SKIPPED;
4888                 }
4889                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4890                         return TEST_SKIPPED;
4891         }
4892
4893         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4894                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4895                 printf("Device doesn't support RAW data-path APIs.\n");
4896                 return TEST_SKIPPED;
4897         }
4898
4899         /* Create SNOW 3G session */
4900         retval = create_wireless_algo_auth_cipher_session(
4901                         ts_params->valid_devs[0],
4902                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4903                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4904                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4905                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4906                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4907                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4908                         tdata->key.data, tdata->key.len,
4909                         tdata->auth_iv.len, tdata->digest.len,
4910                         tdata->cipher_iv.len);
4911         if (retval != 0)
4912                 return retval;
4913
4914         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4915         if (op_mode == OUT_OF_PLACE)
4916                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4917
4918         /* clear mbuf payload */
4919         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4920                 rte_pktmbuf_tailroom(ut_params->ibuf));
4921         if (op_mode == OUT_OF_PLACE)
4922                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4923                         rte_pktmbuf_tailroom(ut_params->obuf));
4924
4925         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4926         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4927         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4928         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4929
4930         if (verify) {
4931                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4932                                         ciphertext_pad_len);
4933                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4934                 if (op_mode == OUT_OF_PLACE)
4935                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4936                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4937                         ciphertext_len);
4938         } else {
4939                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4940                                         plaintext_pad_len);
4941                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4942                 if (op_mode == OUT_OF_PLACE)
4943                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4944                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4945         }
4946
4947         /* Create SNOW 3G operation */
4948         retval = create_wireless_algo_auth_cipher_operation(
4949                 tdata->digest.data, tdata->digest.len,
4950                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4951                 tdata->auth_iv.data, tdata->auth_iv.len,
4952                 (tdata->digest.offset_bytes == 0 ?
4953                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4954                         : tdata->digest.offset_bytes),
4955                 tdata->validCipherLenInBits.len,
4956                 tdata->cipher.offset_bits,
4957                 tdata->validAuthLenInBits.len,
4958                 tdata->auth.offset_bits,
4959                 op_mode, 0, verify);
4960
4961         if (retval < 0)
4962                 return retval;
4963
4964         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4965                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4966                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4967         else
4968                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4969                         ut_params->op);
4970
4971         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4972
4973         ut_params->obuf = (op_mode == IN_PLACE ?
4974                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4975
4976         if (verify) {
4977                 if (ut_params->obuf)
4978                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4979                                                         uint8_t *);
4980                 else
4981                         plaintext = ciphertext +
4982                                 (tdata->cipher.offset_bits >> 3);
4983
4984                 debug_hexdump(stdout, "plaintext:", plaintext,
4985                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4986                 debug_hexdump(stdout, "plaintext expected:",
4987                         tdata->plaintext.data,
4988                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4989         } else {
4990                 if (ut_params->obuf)
4991                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4992                                                         uint8_t *);
4993                 else
4994                         ciphertext = plaintext;
4995
4996                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4997                         ciphertext_len);
4998                 debug_hexdump(stdout, "ciphertext expected:",
4999                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5000
5001                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5002                         + (tdata->digest.offset_bytes == 0 ?
5003                 plaintext_pad_len : tdata->digest.offset_bytes);
5004
5005                 debug_hexdump(stdout, "digest:", ut_params->digest,
5006                         tdata->digest.len);
5007                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5008                                 tdata->digest.len);
5009         }
5010
5011         /* Validate obuf */
5012         if (verify) {
5013                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5014                         plaintext,
5015                         tdata->plaintext.data,
5016                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5017                          (tdata->digest.len << 3)),
5018                         tdata->cipher.offset_bits,
5019                         "SNOW 3G Plaintext data not as expected");
5020         } else {
5021                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5022                         ciphertext,
5023                         tdata->ciphertext.data,
5024                         (tdata->validDataLenInBits.len -
5025                          tdata->cipher.offset_bits),
5026                         tdata->cipher.offset_bits,
5027                         "SNOW 3G Ciphertext data not as expected");
5028
5029                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5030                         ut_params->digest,
5031                         tdata->digest.data,
5032                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5033                         "SNOW 3G Generated auth tag not as expected");
5034         }
5035         return 0;
5036 }
5037
5038 static int
5039 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5040         uint8_t op_mode, uint8_t verify)
5041 {
5042         struct crypto_testsuite_params *ts_params = &testsuite_params;
5043         struct crypto_unittest_params *ut_params = &unittest_params;
5044
5045         int retval;
5046
5047         const uint8_t *plaintext = NULL;
5048         const uint8_t *ciphertext = NULL;
5049         const uint8_t *digest = NULL;
5050         unsigned int plaintext_pad_len;
5051         unsigned int plaintext_len;
5052         unsigned int ciphertext_pad_len;
5053         unsigned int ciphertext_len;
5054         uint8_t buffer[10000];
5055         uint8_t digest_buffer[10000];
5056
5057         struct rte_cryptodev_info dev_info;
5058
5059         /* Verify the capabilities */
5060         struct rte_cryptodev_sym_capability_idx cap_idx;
5061         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5062         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5063         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5064                         &cap_idx) == NULL)
5065                 return TEST_SKIPPED;
5066         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5067         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5068         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5069                         &cap_idx) == NULL)
5070                 return TEST_SKIPPED;
5071
5072         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5073                 return TEST_SKIPPED;
5074
5075         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5076
5077         uint64_t feat_flags = dev_info.feature_flags;
5078
5079         if (op_mode == IN_PLACE) {
5080                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5081                         printf("Device doesn't support in-place scatter-gather "
5082                                         "in both input and output mbufs.\n");
5083                         return TEST_SKIPPED;
5084                 }
5085                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5086                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5087                         printf("Device doesn't support RAW data-path APIs.\n");
5088                         return TEST_SKIPPED;
5089                 }
5090         } else {
5091                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5092                         return TEST_SKIPPED;
5093                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5094                         printf("Device doesn't support out-of-place scatter-gather "
5095                                         "in both input and output mbufs.\n");
5096                         return TEST_SKIPPED;
5097                 }
5098                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5099                         printf("Device doesn't support digest encrypted.\n");
5100                         return TEST_SKIPPED;
5101                 }
5102         }
5103
5104         /* Create SNOW 3G session */
5105         retval = create_wireless_algo_auth_cipher_session(
5106                         ts_params->valid_devs[0],
5107                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5108                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5109                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5110                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5111                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5112                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5113                         tdata->key.data, tdata->key.len,
5114                         tdata->auth_iv.len, tdata->digest.len,
5115                         tdata->cipher_iv.len);
5116
5117         if (retval != 0)
5118                 return retval;
5119
5120         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5121         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5122         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5123         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5124
5125         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5126                         plaintext_pad_len, 15, 0);
5127         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5128                         "Failed to allocate input buffer in mempool");
5129
5130         if (op_mode == OUT_OF_PLACE) {
5131                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5132                                 plaintext_pad_len, 15, 0);
5133                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5134                                 "Failed to allocate output buffer in mempool");
5135         }
5136
5137         if (verify) {
5138                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5139                         tdata->ciphertext.data);
5140                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5141                                         ciphertext_len, buffer);
5142                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5143                         ciphertext_len);
5144         } else {
5145                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5146                         tdata->plaintext.data);
5147                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5148                                         plaintext_len, buffer);
5149                 debug_hexdump(stdout, "plaintext:", plaintext,
5150                         plaintext_len);
5151         }
5152         memset(buffer, 0, sizeof(buffer));
5153
5154         /* Create SNOW 3G operation */
5155         retval = create_wireless_algo_auth_cipher_operation(
5156                 tdata->digest.data, tdata->digest.len,
5157                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5158                 tdata->auth_iv.data, tdata->auth_iv.len,
5159                 (tdata->digest.offset_bytes == 0 ?
5160                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5161                         : tdata->digest.offset_bytes),
5162                 tdata->validCipherLenInBits.len,
5163                 tdata->cipher.offset_bits,
5164                 tdata->validAuthLenInBits.len,
5165                 tdata->auth.offset_bits,
5166                 op_mode, 1, verify);
5167
5168         if (retval < 0)
5169                 return retval;
5170
5171         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5172                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5173                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5174         else
5175                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5176                         ut_params->op);
5177
5178         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5179
5180         ut_params->obuf = (op_mode == IN_PLACE ?
5181                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5182
5183         if (verify) {
5184                 if (ut_params->obuf)
5185                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5186                                         plaintext_len, buffer);
5187                 else
5188                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5189                                         plaintext_len, buffer);
5190
5191                 debug_hexdump(stdout, "plaintext:", plaintext,
5192                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5193                 debug_hexdump(stdout, "plaintext expected:",
5194                         tdata->plaintext.data,
5195                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5196         } else {
5197                 if (ut_params->obuf)
5198                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5199                                         ciphertext_len, buffer);
5200                 else
5201                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5202                                         ciphertext_len, buffer);
5203
5204                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5205                         ciphertext_len);
5206                 debug_hexdump(stdout, "ciphertext expected:",
5207                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5208
5209                 if (ut_params->obuf)
5210                         digest = rte_pktmbuf_read(ut_params->obuf,
5211                                 (tdata->digest.offset_bytes == 0 ?
5212                                 plaintext_pad_len : tdata->digest.offset_bytes),
5213                                 tdata->digest.len, digest_buffer);
5214                 else
5215                         digest = rte_pktmbuf_read(ut_params->ibuf,
5216                                 (tdata->digest.offset_bytes == 0 ?
5217                                 plaintext_pad_len : tdata->digest.offset_bytes),
5218                                 tdata->digest.len, digest_buffer);
5219
5220                 debug_hexdump(stdout, "digest:", digest,
5221                         tdata->digest.len);
5222                 debug_hexdump(stdout, "digest expected:",
5223                         tdata->digest.data, tdata->digest.len);
5224         }
5225
5226         /* Validate obuf */
5227         if (verify) {
5228                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5229                         plaintext,
5230                         tdata->plaintext.data,
5231                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5232                          (tdata->digest.len << 3)),
5233                         tdata->cipher.offset_bits,
5234                         "SNOW 3G Plaintext data not as expected");
5235         } else {
5236                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5237                         ciphertext,
5238                         tdata->ciphertext.data,
5239                         (tdata->validDataLenInBits.len -
5240                          tdata->cipher.offset_bits),
5241                         tdata->cipher.offset_bits,
5242                         "SNOW 3G Ciphertext data not as expected");
5243
5244                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5245                         digest,
5246                         tdata->digest.data,
5247                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5248                         "SNOW 3G Generated auth tag not as expected");
5249         }
5250         return 0;
5251 }
5252
5253 static int
5254 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5255         uint8_t op_mode, uint8_t verify)
5256 {
5257         struct crypto_testsuite_params *ts_params = &testsuite_params;
5258         struct crypto_unittest_params *ut_params = &unittest_params;
5259
5260         int retval;
5261
5262         uint8_t *plaintext = NULL, *ciphertext = NULL;
5263         unsigned int plaintext_pad_len;
5264         unsigned int plaintext_len;
5265         unsigned int ciphertext_pad_len;
5266         unsigned int ciphertext_len;
5267
5268         struct rte_cryptodev_info dev_info;
5269
5270         /* Verify the capabilities */
5271         struct rte_cryptodev_sym_capability_idx cap_idx;
5272         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5273         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5274         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5275                         &cap_idx) == NULL)
5276                 return TEST_SKIPPED;
5277         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5278         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5279         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5280                         &cap_idx) == NULL)
5281                 return TEST_SKIPPED;
5282
5283         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5284
5285         uint64_t feat_flags = dev_info.feature_flags;
5286
5287         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5288                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5289                 printf("Device doesn't support RAW data-path APIs.\n");
5290                 return TEST_SKIPPED;
5291         }
5292
5293         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5294                 return TEST_SKIPPED;
5295
5296         if (op_mode == OUT_OF_PLACE) {
5297                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5298                         return TEST_SKIPPED;
5299                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5300                         printf("Device doesn't support digest encrypted.\n");
5301                         return TEST_SKIPPED;
5302                 }
5303         }
5304
5305         /* Create KASUMI session */
5306         retval = create_wireless_algo_auth_cipher_session(
5307                         ts_params->valid_devs[0],
5308                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5309                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5310                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5311                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5312                         RTE_CRYPTO_AUTH_KASUMI_F9,
5313                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5314                         tdata->key.data, tdata->key.len,
5315                         0, tdata->digest.len,
5316                         tdata->cipher_iv.len);
5317
5318         if (retval != 0)
5319                 return retval;
5320
5321         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5322         if (op_mode == OUT_OF_PLACE)
5323                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5324
5325         /* clear mbuf payload */
5326         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5327                 rte_pktmbuf_tailroom(ut_params->ibuf));
5328         if (op_mode == OUT_OF_PLACE)
5329                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5330                         rte_pktmbuf_tailroom(ut_params->obuf));
5331
5332         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5333         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5334         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5335         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5336
5337         if (verify) {
5338                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5339                                         ciphertext_pad_len);
5340                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5341                 if (op_mode == OUT_OF_PLACE)
5342                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5343                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5344                         ciphertext_len);
5345         } else {
5346                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5347                                         plaintext_pad_len);
5348                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5349                 if (op_mode == OUT_OF_PLACE)
5350                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5351                 debug_hexdump(stdout, "plaintext:", plaintext,
5352                         plaintext_len);
5353         }
5354
5355         /* Create KASUMI operation */
5356         retval = create_wireless_algo_auth_cipher_operation(
5357                 tdata->digest.data, tdata->digest.len,
5358                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5359                 NULL, 0,
5360                 (tdata->digest.offset_bytes == 0 ?
5361                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5362                         : tdata->digest.offset_bytes),
5363                 tdata->validCipherLenInBits.len,
5364                 tdata->validCipherOffsetInBits.len,
5365                 tdata->validAuthLenInBits.len,
5366                 0,
5367                 op_mode, 0, verify);
5368
5369         if (retval < 0)
5370                 return retval;
5371
5372         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5373                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5374                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5375         else
5376                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5377                         ut_params->op);
5378
5379         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5380
5381         ut_params->obuf = (op_mode == IN_PLACE ?
5382                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5383
5384
5385         if (verify) {
5386                 if (ut_params->obuf)
5387                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5388                                                         uint8_t *);
5389                 else
5390                         plaintext = ciphertext;
5391
5392                 debug_hexdump(stdout, "plaintext:", plaintext,
5393                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5394                 debug_hexdump(stdout, "plaintext expected:",
5395                         tdata->plaintext.data,
5396                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5397         } else {
5398                 if (ut_params->obuf)
5399                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5400                                                         uint8_t *);
5401                 else
5402                         ciphertext = plaintext;
5403
5404                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5405                         ciphertext_len);
5406                 debug_hexdump(stdout, "ciphertext expected:",
5407                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5408
5409                 ut_params->digest = rte_pktmbuf_mtod(
5410                         ut_params->obuf, uint8_t *) +
5411                         (tdata->digest.offset_bytes == 0 ?
5412                         plaintext_pad_len : tdata->digest.offset_bytes);
5413
5414                 debug_hexdump(stdout, "digest:", ut_params->digest,
5415                         tdata->digest.len);
5416                 debug_hexdump(stdout, "digest expected:",
5417                         tdata->digest.data, tdata->digest.len);
5418         }
5419
5420         /* Validate obuf */
5421         if (verify) {
5422                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5423                         plaintext,
5424                         tdata->plaintext.data,
5425                         tdata->plaintext.len >> 3,
5426                         "KASUMI Plaintext data not as expected");
5427         } else {
5428                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5429                         ciphertext,
5430                         tdata->ciphertext.data,
5431                         tdata->ciphertext.len >> 3,
5432                         "KASUMI Ciphertext data not as expected");
5433
5434                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5435                         ut_params->digest,
5436                         tdata->digest.data,
5437                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5438                         "KASUMI Generated auth tag not as expected");
5439         }
5440         return 0;
5441 }
5442
5443 static int
5444 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5445         uint8_t op_mode, uint8_t verify)
5446 {
5447         struct crypto_testsuite_params *ts_params = &testsuite_params;
5448         struct crypto_unittest_params *ut_params = &unittest_params;
5449
5450         int retval;
5451
5452         const uint8_t *plaintext = NULL;
5453         const uint8_t *ciphertext = NULL;
5454         const uint8_t *digest = NULL;
5455         unsigned int plaintext_pad_len;
5456         unsigned int plaintext_len;
5457         unsigned int ciphertext_pad_len;
5458         unsigned int ciphertext_len;
5459         uint8_t buffer[10000];
5460         uint8_t digest_buffer[10000];
5461
5462         struct rte_cryptodev_info dev_info;
5463
5464         /* Verify the capabilities */
5465         struct rte_cryptodev_sym_capability_idx cap_idx;
5466         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5467         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5468         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5469                         &cap_idx) == NULL)
5470                 return TEST_SKIPPED;
5471         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5472         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5473         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5474                         &cap_idx) == NULL)
5475                 return TEST_SKIPPED;
5476
5477         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5478                 return TEST_SKIPPED;
5479
5480         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5481
5482         uint64_t feat_flags = dev_info.feature_flags;
5483
5484         if (op_mode == IN_PLACE) {
5485                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5486                         printf("Device doesn't support in-place scatter-gather "
5487                                         "in both input and output mbufs.\n");
5488                         return TEST_SKIPPED;
5489                 }
5490                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5491                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5492                         printf("Device doesn't support RAW data-path APIs.\n");
5493                         return TEST_SKIPPED;
5494                 }
5495         } else {
5496                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5497                         return TEST_SKIPPED;
5498                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5499                         printf("Device doesn't support out-of-place scatter-gather "
5500                                         "in both input and output mbufs.\n");
5501                         return TEST_SKIPPED;
5502                 }
5503                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5504                         printf("Device doesn't support digest encrypted.\n");
5505                         return TEST_SKIPPED;
5506                 }
5507         }
5508
5509         /* Create KASUMI session */
5510         retval = create_wireless_algo_auth_cipher_session(
5511                         ts_params->valid_devs[0],
5512                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5513                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5514                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5515                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5516                         RTE_CRYPTO_AUTH_KASUMI_F9,
5517                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5518                         tdata->key.data, tdata->key.len,
5519                         0, tdata->digest.len,
5520                         tdata->cipher_iv.len);
5521
5522         if (retval != 0)
5523                 return retval;
5524
5525         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5526         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5527         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5528         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5529
5530         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5531                         plaintext_pad_len, 15, 0);
5532         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5533                         "Failed to allocate input buffer in mempool");
5534
5535         if (op_mode == OUT_OF_PLACE) {
5536                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5537                                 plaintext_pad_len, 15, 0);
5538                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5539                                 "Failed to allocate output buffer in mempool");
5540         }
5541
5542         if (verify) {
5543                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5544                         tdata->ciphertext.data);
5545                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5546                                         ciphertext_len, buffer);
5547                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5548                         ciphertext_len);
5549         } else {
5550                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5551                         tdata->plaintext.data);
5552                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5553                                         plaintext_len, buffer);
5554                 debug_hexdump(stdout, "plaintext:", plaintext,
5555                         plaintext_len);
5556         }
5557         memset(buffer, 0, sizeof(buffer));
5558
5559         /* Create KASUMI operation */
5560         retval = create_wireless_algo_auth_cipher_operation(
5561                 tdata->digest.data, tdata->digest.len,
5562                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5563                 NULL, 0,
5564                 (tdata->digest.offset_bytes == 0 ?
5565                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5566                         : tdata->digest.offset_bytes),
5567                 tdata->validCipherLenInBits.len,
5568                 tdata->validCipherOffsetInBits.len,
5569                 tdata->validAuthLenInBits.len,
5570                 0,
5571                 op_mode, 1, verify);
5572
5573         if (retval < 0)
5574                 return retval;
5575
5576         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5577                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5578                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5579         else
5580                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5581                         ut_params->op);
5582
5583         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5584
5585         ut_params->obuf = (op_mode == IN_PLACE ?
5586                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5587
5588         if (verify) {
5589                 if (ut_params->obuf)
5590                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5591                                         plaintext_len, buffer);
5592                 else
5593                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5594                                         plaintext_len, buffer);
5595
5596                 debug_hexdump(stdout, "plaintext:", plaintext,
5597                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5598                 debug_hexdump(stdout, "plaintext expected:",
5599                         tdata->plaintext.data,
5600                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5601         } else {
5602                 if (ut_params->obuf)
5603                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5604                                         ciphertext_len, buffer);
5605                 else
5606                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5607                                         ciphertext_len, buffer);
5608
5609                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5610                         ciphertext_len);
5611                 debug_hexdump(stdout, "ciphertext expected:",
5612                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5613
5614                 if (ut_params->obuf)
5615                         digest = rte_pktmbuf_read(ut_params->obuf,
5616                                 (tdata->digest.offset_bytes == 0 ?
5617                                 plaintext_pad_len : tdata->digest.offset_bytes),
5618                                 tdata->digest.len, digest_buffer);
5619                 else
5620                         digest = rte_pktmbuf_read(ut_params->ibuf,
5621                                 (tdata->digest.offset_bytes == 0 ?
5622                                 plaintext_pad_len : tdata->digest.offset_bytes),
5623                                 tdata->digest.len, digest_buffer);
5624
5625                 debug_hexdump(stdout, "digest:", digest,
5626                         tdata->digest.len);
5627                 debug_hexdump(stdout, "digest expected:",
5628                         tdata->digest.data, tdata->digest.len);
5629         }
5630
5631         /* Validate obuf */
5632         if (verify) {
5633                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5634                         plaintext,
5635                         tdata->plaintext.data,
5636                         tdata->plaintext.len >> 3,
5637                         "KASUMI Plaintext data not as expected");
5638         } else {
5639                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5640                         ciphertext,
5641                         tdata->ciphertext.data,
5642                         tdata->validDataLenInBits.len,
5643                         "KASUMI Ciphertext data not as expected");
5644
5645                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5646                         digest,
5647                         tdata->digest.data,
5648                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5649                         "KASUMI Generated auth tag not as expected");
5650         }
5651         return 0;
5652 }
5653
5654 static int
5655 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5656 {
5657         struct crypto_testsuite_params *ts_params = &testsuite_params;
5658         struct crypto_unittest_params *ut_params = &unittest_params;
5659
5660         int retval;
5661
5662         uint8_t *plaintext, *ciphertext;
5663         unsigned plaintext_pad_len;
5664         unsigned plaintext_len;
5665         struct rte_cryptodev_info dev_info;
5666
5667         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5668         uint64_t feat_flags = dev_info.feature_flags;
5669
5670         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5671                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5672                 printf("Device doesn't support RAW data-path APIs.\n");
5673                 return TEST_SKIPPED;
5674         }
5675
5676         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5677                 return TEST_SKIPPED;
5678
5679         /* Verify the capabilities */
5680         struct rte_cryptodev_sym_capability_idx cap_idx;
5681         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5682         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5683         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5684                         &cap_idx) == NULL)
5685                 return TEST_SKIPPED;
5686         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5687         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5688         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5689                         &cap_idx) == NULL)
5690                 return TEST_SKIPPED;
5691
5692         /* Create KASUMI session */
5693         retval = create_wireless_algo_cipher_auth_session(
5694                         ts_params->valid_devs[0],
5695                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5696                         RTE_CRYPTO_AUTH_OP_GENERATE,
5697                         RTE_CRYPTO_AUTH_KASUMI_F9,
5698                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5699                         tdata->key.data, tdata->key.len,
5700                         0, tdata->digest.len,
5701                         tdata->cipher_iv.len);
5702         if (retval != 0)
5703                 return retval;
5704
5705         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5706
5707         /* clear mbuf payload */
5708         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5709                         rte_pktmbuf_tailroom(ut_params->ibuf));
5710
5711         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5712         /* Append data which is padded to a multiple of */
5713         /* the algorithms block size */
5714         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5715         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5716                                 plaintext_pad_len);
5717         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5718
5719         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5720
5721         /* Create KASUMI operation */
5722         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5723                                 tdata->digest.len, NULL, 0,
5724                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5725                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5726                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5727                                 tdata->validCipherOffsetInBits.len,
5728                                 tdata->validAuthLenInBits.len,
5729                                 0
5730                                 );
5731         if (retval < 0)
5732                 return retval;
5733
5734         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5735                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5736                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5737         else
5738                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5739                         ut_params->op);
5740         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5741
5742         if (ut_params->op->sym->m_dst)
5743                 ut_params->obuf = ut_params->op->sym->m_dst;
5744         else
5745                 ut_params->obuf = ut_params->op->sym->m_src;
5746
5747         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5748                                 tdata->validCipherOffsetInBits.len >> 3);
5749
5750         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5751                         + plaintext_pad_len;
5752
5753         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5754                                 (tdata->validCipherOffsetInBits.len >> 3);
5755         /* Validate obuf */
5756         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5757                 ciphertext,
5758                 reference_ciphertext,
5759                 tdata->validCipherLenInBits.len,
5760                 "KASUMI Ciphertext data not as expected");
5761
5762         /* Validate obuf */
5763         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5764                 ut_params->digest,
5765                 tdata->digest.data,
5766                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5767                 "KASUMI Generated auth tag not as expected");
5768         return 0;
5769 }
5770
5771 static int
5772 test_zuc_encryption(const struct wireless_test_data *tdata)
5773 {
5774         struct crypto_testsuite_params *ts_params = &testsuite_params;
5775         struct crypto_unittest_params *ut_params = &unittest_params;
5776
5777         int retval;
5778         uint8_t *plaintext, *ciphertext;
5779         unsigned plaintext_pad_len;
5780         unsigned plaintext_len;
5781         struct rte_cryptodev_info dev_info;
5782
5783         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5784         uint64_t feat_flags = dev_info.feature_flags;
5785
5786         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5787                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5788                 printf("Device doesn't support RAW data-path APIs.\n");
5789                 return TEST_SKIPPED;
5790         }
5791
5792         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5793                 return TEST_SKIPPED;
5794
5795         struct rte_cryptodev_sym_capability_idx cap_idx;
5796
5797         /* Check if device supports ZUC EEA3 */
5798         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5799         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5800
5801         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5802                         &cap_idx) == NULL)
5803                 return TEST_SKIPPED;
5804
5805         /* Create ZUC session */
5806         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5807                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5808                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5809                                         tdata->key.data, tdata->key.len,
5810                                         tdata->cipher_iv.len);
5811         if (retval < 0)
5812                 return retval;
5813
5814         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5815
5816         /* Clear mbuf payload */
5817         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5818                rte_pktmbuf_tailroom(ut_params->ibuf));
5819
5820         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5821         /* Append data which is padded to a multiple */
5822         /* of the algorithms block size */
5823         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5824         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5825                                 plaintext_pad_len);
5826         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5827
5828         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5829
5830         /* Create ZUC operation */
5831         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5832                                         tdata->cipher_iv.len,
5833                                         tdata->plaintext.len,
5834                                         0);
5835         if (retval < 0)
5836                 return retval;
5837
5838         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5839                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5840                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5841         else
5842                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5843                                                 ut_params->op);
5844         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5845
5846         ut_params->obuf = ut_params->op->sym->m_dst;
5847         if (ut_params->obuf)
5848                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5849         else
5850                 ciphertext = plaintext;
5851
5852         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5853
5854         /* Validate obuf */
5855         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5856                 ciphertext,
5857                 tdata->ciphertext.data,
5858                 tdata->validCipherLenInBits.len,
5859                 "ZUC Ciphertext data not as expected");
5860         return 0;
5861 }
5862
5863 static int
5864 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5865 {
5866         struct crypto_testsuite_params *ts_params = &testsuite_params;
5867         struct crypto_unittest_params *ut_params = &unittest_params;
5868
5869         int retval;
5870
5871         unsigned int plaintext_pad_len;
5872         unsigned int plaintext_len;
5873         const uint8_t *ciphertext;
5874         uint8_t ciphertext_buffer[2048];
5875         struct rte_cryptodev_info dev_info;
5876
5877         struct rte_cryptodev_sym_capability_idx cap_idx;
5878
5879         /* Check if device supports ZUC EEA3 */
5880         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5881         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5882
5883         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5884                         &cap_idx) == NULL)
5885                 return TEST_SKIPPED;
5886
5887         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5888                 return TEST_SKIPPED;
5889
5890         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5891
5892         uint64_t feat_flags = dev_info.feature_flags;
5893
5894         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5895                 printf("Device doesn't support in-place scatter-gather. "
5896                                 "Test Skipped.\n");
5897                 return TEST_SKIPPED;
5898         }
5899
5900         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5901                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5902                 printf("Device doesn't support RAW data-path APIs.\n");
5903                 return TEST_SKIPPED;
5904         }
5905
5906         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5907
5908         /* Append data which is padded to a multiple */
5909         /* of the algorithms block size */
5910         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5911
5912         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5913                         plaintext_pad_len, 10, 0);
5914
5915         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5916                         tdata->plaintext.data);
5917
5918         /* Create ZUC session */
5919         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5920                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5921                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5922                         tdata->key.data, tdata->key.len,
5923                         tdata->cipher_iv.len);
5924         if (retval < 0)
5925                 return retval;
5926
5927         /* Clear mbuf payload */
5928
5929         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5930
5931         /* Create ZUC operation */
5932         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5933                         tdata->cipher_iv.len, tdata->plaintext.len,
5934                         0);
5935         if (retval < 0)
5936                 return retval;
5937
5938         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5939                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5940                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5941         else
5942                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5943                                                 ut_params->op);
5944         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5945
5946         ut_params->obuf = ut_params->op->sym->m_dst;
5947         if (ut_params->obuf)
5948                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5949                         0, plaintext_len, ciphertext_buffer);
5950         else
5951                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5952                         0, plaintext_len, ciphertext_buffer);
5953
5954         /* Validate obuf */
5955         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5956
5957         /* Validate obuf */
5958         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5959                 ciphertext,
5960                 tdata->ciphertext.data,
5961                 tdata->validCipherLenInBits.len,
5962                 "ZUC Ciphertext data not as expected");
5963
5964         return 0;
5965 }
5966
5967 static int
5968 test_zuc_authentication(const struct wireless_test_data *tdata)
5969 {
5970         struct crypto_testsuite_params *ts_params = &testsuite_params;
5971         struct crypto_unittest_params *ut_params = &unittest_params;
5972
5973         int retval;
5974         unsigned plaintext_pad_len;
5975         unsigned plaintext_len;
5976         uint8_t *plaintext;
5977
5978         struct rte_cryptodev_sym_capability_idx cap_idx;
5979         struct rte_cryptodev_info dev_info;
5980
5981         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5982         uint64_t feat_flags = dev_info.feature_flags;
5983
5984         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5985                         (tdata->validAuthLenInBits.len % 8 != 0)) {
5986                 printf("Device doesn't support NON-Byte Aligned Data.\n");
5987                 return TEST_SKIPPED;
5988         }
5989
5990         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5991                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5992                 printf("Device doesn't support RAW data-path APIs.\n");
5993                 return TEST_SKIPPED;
5994         }
5995
5996         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5997                 return TEST_SKIPPED;
5998
5999         /* Check if device supports ZUC EIA3 */
6000         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6001         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6002
6003         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6004                         &cap_idx) == NULL)
6005                 return TEST_SKIPPED;
6006
6007         /* Create ZUC session */
6008         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6009                         tdata->key.data, tdata->key.len,
6010                         tdata->auth_iv.len, tdata->digest.len,
6011                         RTE_CRYPTO_AUTH_OP_GENERATE,
6012                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6013         if (retval < 0)
6014                 return retval;
6015
6016         /* alloc mbuf and set payload */
6017         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6018
6019         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6020         rte_pktmbuf_tailroom(ut_params->ibuf));
6021
6022         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6023         /* Append data which is padded to a multiple of */
6024         /* the algorithms block size */
6025         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6026         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6027                                 plaintext_pad_len);
6028         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6029
6030         /* Create ZUC operation */
6031         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6032                         tdata->auth_iv.data, tdata->auth_iv.len,
6033                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6034                         tdata->validAuthLenInBits.len,
6035                         0);
6036         if (retval < 0)
6037                 return retval;
6038
6039         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6040                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6041                                 ut_params->op, 0, 1, 1, 0);
6042         else
6043                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6044                                 ut_params->op);
6045         ut_params->obuf = ut_params->op->sym->m_src;
6046         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6047         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6048                         + plaintext_pad_len;
6049
6050         /* Validate obuf */
6051         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6052         ut_params->digest,
6053         tdata->digest.data,
6054         tdata->digest.len,
6055         "ZUC Generated auth tag not as expected");
6056
6057         return 0;
6058 }
6059
6060 static int
6061 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6062         uint8_t op_mode, uint8_t verify)
6063 {
6064         struct crypto_testsuite_params *ts_params = &testsuite_params;
6065         struct crypto_unittest_params *ut_params = &unittest_params;
6066
6067         int retval;
6068
6069         uint8_t *plaintext = NULL, *ciphertext = NULL;
6070         unsigned int plaintext_pad_len;
6071         unsigned int plaintext_len;
6072         unsigned int ciphertext_pad_len;
6073         unsigned int ciphertext_len;
6074
6075         struct rte_cryptodev_info dev_info;
6076         struct rte_cryptodev_sym_capability_idx cap_idx;
6077
6078         /* Check if device supports ZUC EIA3 */
6079         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6080         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6081
6082         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6083                         &cap_idx) == NULL)
6084                 return TEST_SKIPPED;
6085
6086         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6087
6088         uint64_t feat_flags = dev_info.feature_flags;
6089
6090         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6091                 printf("Device doesn't support digest encrypted.\n");
6092                 return TEST_SKIPPED;
6093         }
6094         if (op_mode == IN_PLACE) {
6095                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6096                         printf("Device doesn't support in-place scatter-gather "
6097                                         "in both input and output mbufs.\n");
6098                         return TEST_SKIPPED;
6099                 }
6100
6101                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6102                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6103                         printf("Device doesn't support RAW data-path APIs.\n");
6104                         return TEST_SKIPPED;
6105                 }
6106         } else {
6107                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6108                         return TEST_SKIPPED;
6109                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6110                         printf("Device doesn't support out-of-place scatter-gather "
6111                                         "in both input and output mbufs.\n");
6112                         return TEST_SKIPPED;
6113                 }
6114         }
6115
6116         /* Create ZUC session */
6117         retval = create_wireless_algo_auth_cipher_session(
6118                         ts_params->valid_devs[0],
6119                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6120                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6121                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6122                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6123                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6124                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6125                         tdata->key.data, tdata->key.len,
6126                         tdata->auth_iv.len, tdata->digest.len,
6127                         tdata->cipher_iv.len);
6128
6129         if (retval != 0)
6130                 return retval;
6131
6132         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6133         if (op_mode == OUT_OF_PLACE)
6134                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6135
6136         /* clear mbuf payload */
6137         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6138                 rte_pktmbuf_tailroom(ut_params->ibuf));
6139         if (op_mode == OUT_OF_PLACE)
6140                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6141                         rte_pktmbuf_tailroom(ut_params->obuf));
6142
6143         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6144         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6145         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6146         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6147
6148         if (verify) {
6149                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6150                                         ciphertext_pad_len);
6151                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6152                 if (op_mode == OUT_OF_PLACE)
6153                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6154                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6155                         ciphertext_len);
6156         } else {
6157                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6158                                         plaintext_pad_len);
6159                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6160                 if (op_mode == OUT_OF_PLACE)
6161                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6162                 debug_hexdump(stdout, "plaintext:", plaintext,
6163                         plaintext_len);
6164         }
6165
6166         /* Create ZUC operation */
6167         retval = create_wireless_algo_auth_cipher_operation(
6168                 tdata->digest.data, tdata->digest.len,
6169                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6170                 tdata->auth_iv.data, tdata->auth_iv.len,
6171                 (tdata->digest.offset_bytes == 0 ?
6172                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6173                         : tdata->digest.offset_bytes),
6174                 tdata->validCipherLenInBits.len,
6175                 tdata->validCipherOffsetInBits.len,
6176                 tdata->validAuthLenInBits.len,
6177                 0,
6178                 op_mode, 0, verify);
6179
6180         if (retval < 0)
6181                 return retval;
6182
6183         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6184                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6185                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6186         else
6187                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6188                         ut_params->op);
6189
6190         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6191
6192         ut_params->obuf = (op_mode == IN_PLACE ?
6193                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6194
6195
6196         if (verify) {
6197                 if (ut_params->obuf)
6198                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6199                                                         uint8_t *);
6200                 else
6201                         plaintext = ciphertext;
6202
6203                 debug_hexdump(stdout, "plaintext:", plaintext,
6204                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6205                 debug_hexdump(stdout, "plaintext expected:",
6206                         tdata->plaintext.data,
6207                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6208         } else {
6209                 if (ut_params->obuf)
6210                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6211                                                         uint8_t *);
6212                 else
6213                         ciphertext = plaintext;
6214
6215                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6216                         ciphertext_len);
6217                 debug_hexdump(stdout, "ciphertext expected:",
6218                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6219
6220                 ut_params->digest = rte_pktmbuf_mtod(
6221                         ut_params->obuf, uint8_t *) +
6222                         (tdata->digest.offset_bytes == 0 ?
6223                         plaintext_pad_len : tdata->digest.offset_bytes);
6224
6225                 debug_hexdump(stdout, "digest:", ut_params->digest,
6226                         tdata->digest.len);
6227                 debug_hexdump(stdout, "digest expected:",
6228                         tdata->digest.data, tdata->digest.len);
6229         }
6230
6231         /* Validate obuf */
6232         if (verify) {
6233                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6234                         plaintext,
6235                         tdata->plaintext.data,
6236                         tdata->plaintext.len >> 3,
6237                         "ZUC Plaintext data not as expected");
6238         } else {
6239                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6240                         ciphertext,
6241                         tdata->ciphertext.data,
6242                         tdata->ciphertext.len >> 3,
6243                         "ZUC Ciphertext data not as expected");
6244
6245                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6246                         ut_params->digest,
6247                         tdata->digest.data,
6248                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6249                         "ZUC Generated auth tag not as expected");
6250         }
6251         return 0;
6252 }
6253
6254 static int
6255 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6256         uint8_t op_mode, uint8_t verify)
6257 {
6258         struct crypto_testsuite_params *ts_params = &testsuite_params;
6259         struct crypto_unittest_params *ut_params = &unittest_params;
6260
6261         int retval;
6262
6263         const uint8_t *plaintext = NULL;
6264         const uint8_t *ciphertext = NULL;
6265         const uint8_t *digest = NULL;
6266         unsigned int plaintext_pad_len;
6267         unsigned int plaintext_len;
6268         unsigned int ciphertext_pad_len;
6269         unsigned int ciphertext_len;
6270         uint8_t buffer[10000];
6271         uint8_t digest_buffer[10000];
6272
6273         struct rte_cryptodev_info dev_info;
6274         struct rte_cryptodev_sym_capability_idx cap_idx;
6275
6276         /* Check if device supports ZUC EIA3 */
6277         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6278         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6279
6280         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6281                         &cap_idx) == NULL)
6282                 return TEST_SKIPPED;
6283
6284         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6285
6286         uint64_t feat_flags = dev_info.feature_flags;
6287
6288         if (op_mode == IN_PLACE) {
6289                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6290                         printf("Device doesn't support in-place scatter-gather "
6291                                         "in both input and output mbufs.\n");
6292                         return TEST_SKIPPED;
6293                 }
6294
6295                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6296                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6297                         printf("Device doesn't support RAW data-path APIs.\n");
6298                         return TEST_SKIPPED;
6299                 }
6300         } else {
6301                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6302                         return TEST_SKIPPED;
6303                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6304                         printf("Device doesn't support out-of-place scatter-gather "
6305                                         "in both input and output mbufs.\n");
6306                         return TEST_SKIPPED;
6307                 }
6308                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6309                         printf("Device doesn't support digest encrypted.\n");
6310                         return TEST_SKIPPED;
6311                 }
6312         }
6313
6314         /* Create ZUC session */
6315         retval = create_wireless_algo_auth_cipher_session(
6316                         ts_params->valid_devs[0],
6317                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6318                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6319                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6320                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6321                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6322                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6323                         tdata->key.data, tdata->key.len,
6324                         tdata->auth_iv.len, tdata->digest.len,
6325                         tdata->cipher_iv.len);
6326
6327         if (retval != 0)
6328                 return retval;
6329
6330         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6331         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6332         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6333         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6334
6335         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6336                         plaintext_pad_len, 15, 0);
6337         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6338                         "Failed to allocate input buffer in mempool");
6339
6340         if (op_mode == OUT_OF_PLACE) {
6341                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6342                                 plaintext_pad_len, 15, 0);
6343                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6344                                 "Failed to allocate output buffer in mempool");
6345         }
6346
6347         if (verify) {
6348                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6349                         tdata->ciphertext.data);
6350                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6351                                         ciphertext_len, buffer);
6352                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6353                         ciphertext_len);
6354         } else {
6355                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6356                         tdata->plaintext.data);
6357                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6358                                         plaintext_len, buffer);
6359                 debug_hexdump(stdout, "plaintext:", plaintext,
6360                         plaintext_len);
6361         }
6362         memset(buffer, 0, sizeof(buffer));
6363
6364         /* Create ZUC operation */
6365         retval = create_wireless_algo_auth_cipher_operation(
6366                 tdata->digest.data, tdata->digest.len,
6367                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6368                 NULL, 0,
6369                 (tdata->digest.offset_bytes == 0 ?
6370                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6371                         : tdata->digest.offset_bytes),
6372                 tdata->validCipherLenInBits.len,
6373                 tdata->validCipherOffsetInBits.len,
6374                 tdata->validAuthLenInBits.len,
6375                 0,
6376                 op_mode, 1, verify);
6377
6378         if (retval < 0)
6379                 return retval;
6380
6381         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6382                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6383                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6384         else
6385                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6386                         ut_params->op);
6387
6388         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6389
6390         ut_params->obuf = (op_mode == IN_PLACE ?
6391                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6392
6393         if (verify) {
6394                 if (ut_params->obuf)
6395                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6396                                         plaintext_len, buffer);
6397                 else
6398                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6399                                         plaintext_len, buffer);
6400
6401                 debug_hexdump(stdout, "plaintext:", plaintext,
6402                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6403                 debug_hexdump(stdout, "plaintext expected:",
6404                         tdata->plaintext.data,
6405                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6406         } else {
6407                 if (ut_params->obuf)
6408                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6409                                         ciphertext_len, buffer);
6410                 else
6411                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6412                                         ciphertext_len, buffer);
6413
6414                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6415                         ciphertext_len);
6416                 debug_hexdump(stdout, "ciphertext expected:",
6417                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6418
6419                 if (ut_params->obuf)
6420                         digest = rte_pktmbuf_read(ut_params->obuf,
6421                                 (tdata->digest.offset_bytes == 0 ?
6422                                 plaintext_pad_len : tdata->digest.offset_bytes),
6423                                 tdata->digest.len, digest_buffer);
6424                 else
6425                         digest = rte_pktmbuf_read(ut_params->ibuf,
6426                                 (tdata->digest.offset_bytes == 0 ?
6427                                 plaintext_pad_len : tdata->digest.offset_bytes),
6428                                 tdata->digest.len, digest_buffer);
6429
6430                 debug_hexdump(stdout, "digest:", digest,
6431                         tdata->digest.len);
6432                 debug_hexdump(stdout, "digest expected:",
6433                         tdata->digest.data, tdata->digest.len);
6434         }
6435
6436         /* Validate obuf */
6437         if (verify) {
6438                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6439                         plaintext,
6440                         tdata->plaintext.data,
6441                         tdata->plaintext.len >> 3,
6442                         "ZUC Plaintext data not as expected");
6443         } else {
6444                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6445                         ciphertext,
6446                         tdata->ciphertext.data,
6447                         tdata->validDataLenInBits.len,
6448                         "ZUC Ciphertext data not as expected");
6449
6450                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6451                         digest,
6452                         tdata->digest.data,
6453                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6454                         "ZUC Generated auth tag not as expected");
6455         }
6456         return 0;
6457 }
6458
6459 static int
6460 test_kasumi_encryption_test_case_1(void)
6461 {
6462         return test_kasumi_encryption(&kasumi_test_case_1);
6463 }
6464
6465 static int
6466 test_kasumi_encryption_test_case_1_sgl(void)
6467 {
6468         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6469 }
6470
6471 static int
6472 test_kasumi_encryption_test_case_1_oop(void)
6473 {
6474         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6475 }
6476
6477 static int
6478 test_kasumi_encryption_test_case_1_oop_sgl(void)
6479 {
6480         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6481 }
6482
6483 static int
6484 test_kasumi_encryption_test_case_2(void)
6485 {
6486         return test_kasumi_encryption(&kasumi_test_case_2);
6487 }
6488
6489 static int
6490 test_kasumi_encryption_test_case_3(void)
6491 {
6492         return test_kasumi_encryption(&kasumi_test_case_3);
6493 }
6494
6495 static int
6496 test_kasumi_encryption_test_case_4(void)
6497 {
6498         return test_kasumi_encryption(&kasumi_test_case_4);
6499 }
6500
6501 static int
6502 test_kasumi_encryption_test_case_5(void)
6503 {
6504         return test_kasumi_encryption(&kasumi_test_case_5);
6505 }
6506
6507 static int
6508 test_kasumi_decryption_test_case_1(void)
6509 {
6510         return test_kasumi_decryption(&kasumi_test_case_1);
6511 }
6512
6513 static int
6514 test_kasumi_decryption_test_case_1_oop(void)
6515 {
6516         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6517 }
6518
6519 static int
6520 test_kasumi_decryption_test_case_2(void)
6521 {
6522         return test_kasumi_decryption(&kasumi_test_case_2);
6523 }
6524
6525 static int
6526 test_kasumi_decryption_test_case_3(void)
6527 {
6528         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6529         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6530                 return TEST_SKIPPED;
6531         return test_kasumi_decryption(&kasumi_test_case_3);
6532 }
6533
6534 static int
6535 test_kasumi_decryption_test_case_4(void)
6536 {
6537         return test_kasumi_decryption(&kasumi_test_case_4);
6538 }
6539
6540 static int
6541 test_kasumi_decryption_test_case_5(void)
6542 {
6543         return test_kasumi_decryption(&kasumi_test_case_5);
6544 }
6545 static int
6546 test_snow3g_encryption_test_case_1(void)
6547 {
6548         return test_snow3g_encryption(&snow3g_test_case_1);
6549 }
6550
6551 static int
6552 test_snow3g_encryption_test_case_1_oop(void)
6553 {
6554         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6555 }
6556
6557 static int
6558 test_snow3g_encryption_test_case_1_oop_sgl(void)
6559 {
6560         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6561 }
6562
6563
6564 static int
6565 test_snow3g_encryption_test_case_1_offset_oop(void)
6566 {
6567         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6568 }
6569
6570 static int
6571 test_snow3g_encryption_test_case_2(void)
6572 {
6573         return test_snow3g_encryption(&snow3g_test_case_2);
6574 }
6575
6576 static int
6577 test_snow3g_encryption_test_case_3(void)
6578 {
6579         return test_snow3g_encryption(&snow3g_test_case_3);
6580 }
6581
6582 static int
6583 test_snow3g_encryption_test_case_4(void)
6584 {
6585         return test_snow3g_encryption(&snow3g_test_case_4);
6586 }
6587
6588 static int
6589 test_snow3g_encryption_test_case_5(void)
6590 {
6591         return test_snow3g_encryption(&snow3g_test_case_5);
6592 }
6593
6594 static int
6595 test_snow3g_decryption_test_case_1(void)
6596 {
6597         return test_snow3g_decryption(&snow3g_test_case_1);
6598 }
6599
6600 static int
6601 test_snow3g_decryption_test_case_1_oop(void)
6602 {
6603         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6604 }
6605
6606 static int
6607 test_snow3g_decryption_test_case_2(void)
6608 {
6609         return test_snow3g_decryption(&snow3g_test_case_2);
6610 }
6611
6612 static int
6613 test_snow3g_decryption_test_case_3(void)
6614 {
6615         return test_snow3g_decryption(&snow3g_test_case_3);
6616 }
6617
6618 static int
6619 test_snow3g_decryption_test_case_4(void)
6620 {
6621         return test_snow3g_decryption(&snow3g_test_case_4);
6622 }
6623
6624 static int
6625 test_snow3g_decryption_test_case_5(void)
6626 {
6627         return test_snow3g_decryption(&snow3g_test_case_5);
6628 }
6629
6630 /*
6631  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6632  * Pattern digest from snow3g_test_data must be allocated as
6633  * 4 last bytes in plaintext.
6634  */
6635 static void
6636 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6637                 struct snow3g_hash_test_data *output)
6638 {
6639         if ((pattern != NULL) && (output != NULL)) {
6640                 output->key.len = pattern->key.len;
6641
6642                 memcpy(output->key.data,
6643                 pattern->key.data, pattern->key.len);
6644
6645                 output->auth_iv.len = pattern->auth_iv.len;
6646
6647                 memcpy(output->auth_iv.data,
6648                 pattern->auth_iv.data, pattern->auth_iv.len);
6649
6650                 output->plaintext.len = pattern->plaintext.len;
6651
6652                 memcpy(output->plaintext.data,
6653                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6654
6655                 output->digest.len = pattern->digest.len;
6656
6657                 memcpy(output->digest.data,
6658                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6659                 pattern->digest.len);
6660
6661                 output->validAuthLenInBits.len =
6662                 pattern->validAuthLenInBits.len;
6663         }
6664 }
6665
6666 /*
6667  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6668  */
6669 static int
6670 test_snow3g_decryption_with_digest_test_case_1(void)
6671 {
6672         struct snow3g_hash_test_data snow3g_hash_data;
6673         struct rte_cryptodev_info dev_info;
6674         struct crypto_testsuite_params *ts_params = &testsuite_params;
6675
6676         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6677         uint64_t feat_flags = dev_info.feature_flags;
6678
6679         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6680                 printf("Device doesn't support encrypted digest operations.\n");
6681                 return TEST_SKIPPED;
6682         }
6683
6684         /*
6685          * Function prepare data for hash veryfication test case.
6686          * Digest is allocated in 4 last bytes in plaintext, pattern.
6687          */
6688         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6689
6690         return test_snow3g_decryption(&snow3g_test_case_7) &
6691                         test_snow3g_authentication_verify(&snow3g_hash_data);
6692 }
6693
6694 static int
6695 test_snow3g_cipher_auth_test_case_1(void)
6696 {
6697         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6698 }
6699
6700 static int
6701 test_snow3g_auth_cipher_test_case_1(void)
6702 {
6703         return test_snow3g_auth_cipher(
6704                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6705 }
6706
6707 static int
6708 test_snow3g_auth_cipher_test_case_2(void)
6709 {
6710         return test_snow3g_auth_cipher(
6711                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6712 }
6713
6714 static int
6715 test_snow3g_auth_cipher_test_case_2_oop(void)
6716 {
6717         return test_snow3g_auth_cipher(
6718                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6719 }
6720
6721 static int
6722 test_snow3g_auth_cipher_part_digest_enc(void)
6723 {
6724         return test_snow3g_auth_cipher(
6725                 &snow3g_auth_cipher_partial_digest_encryption,
6726                         IN_PLACE, 0);
6727 }
6728
6729 static int
6730 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6731 {
6732         return test_snow3g_auth_cipher(
6733                 &snow3g_auth_cipher_partial_digest_encryption,
6734                         OUT_OF_PLACE, 0);
6735 }
6736
6737 static int
6738 test_snow3g_auth_cipher_test_case_3_sgl(void)
6739 {
6740         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6741         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6742                 return TEST_SKIPPED;
6743         return test_snow3g_auth_cipher_sgl(
6744                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6745 }
6746
6747 static int
6748 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6749 {
6750         return test_snow3g_auth_cipher_sgl(
6751                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6752 }
6753
6754 static int
6755 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6756 {
6757         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6758         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6759                 return TEST_SKIPPED;
6760         return test_snow3g_auth_cipher_sgl(
6761                 &snow3g_auth_cipher_partial_digest_encryption,
6762                         IN_PLACE, 0);
6763 }
6764
6765 static int
6766 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6767 {
6768         return test_snow3g_auth_cipher_sgl(
6769                 &snow3g_auth_cipher_partial_digest_encryption,
6770                         OUT_OF_PLACE, 0);
6771 }
6772
6773 static int
6774 test_snow3g_auth_cipher_verify_test_case_1(void)
6775 {
6776         return test_snow3g_auth_cipher(
6777                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6778 }
6779
6780 static int
6781 test_snow3g_auth_cipher_verify_test_case_2(void)
6782 {
6783         return test_snow3g_auth_cipher(
6784                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6785 }
6786
6787 static int
6788 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6789 {
6790         return test_snow3g_auth_cipher(
6791                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6792 }
6793
6794 static int
6795 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6796 {
6797         return test_snow3g_auth_cipher(
6798                 &snow3g_auth_cipher_partial_digest_encryption,
6799                         IN_PLACE, 1);
6800 }
6801
6802 static int
6803 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6804 {
6805         return test_snow3g_auth_cipher(
6806                 &snow3g_auth_cipher_partial_digest_encryption,
6807                         OUT_OF_PLACE, 1);
6808 }
6809
6810 static int
6811 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6812 {
6813         return test_snow3g_auth_cipher_sgl(
6814                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6815 }
6816
6817 static int
6818 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6819 {
6820         return test_snow3g_auth_cipher_sgl(
6821                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6822 }
6823
6824 static int
6825 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6826 {
6827         return test_snow3g_auth_cipher_sgl(
6828                 &snow3g_auth_cipher_partial_digest_encryption,
6829                         IN_PLACE, 1);
6830 }
6831
6832 static int
6833 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6834 {
6835         return test_snow3g_auth_cipher_sgl(
6836                 &snow3g_auth_cipher_partial_digest_encryption,
6837                         OUT_OF_PLACE, 1);
6838 }
6839
6840 static int
6841 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6842 {
6843         return test_snow3g_auth_cipher(
6844                 &snow3g_test_case_7, IN_PLACE, 0);
6845 }
6846
6847 static int
6848 test_kasumi_auth_cipher_test_case_1(void)
6849 {
6850         return test_kasumi_auth_cipher(
6851                 &kasumi_test_case_3, IN_PLACE, 0);
6852 }
6853
6854 static int
6855 test_kasumi_auth_cipher_test_case_2(void)
6856 {
6857         return test_kasumi_auth_cipher(
6858                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6859 }
6860
6861 static int
6862 test_kasumi_auth_cipher_test_case_2_oop(void)
6863 {
6864         return test_kasumi_auth_cipher(
6865                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6866 }
6867
6868 static int
6869 test_kasumi_auth_cipher_test_case_2_sgl(void)
6870 {
6871         return test_kasumi_auth_cipher_sgl(
6872                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6873 }
6874
6875 static int
6876 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6877 {
6878         return test_kasumi_auth_cipher_sgl(
6879                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6880 }
6881
6882 static int
6883 test_kasumi_auth_cipher_verify_test_case_1(void)
6884 {
6885         return test_kasumi_auth_cipher(
6886                 &kasumi_test_case_3, IN_PLACE, 1);
6887 }
6888
6889 static int
6890 test_kasumi_auth_cipher_verify_test_case_2(void)
6891 {
6892         return test_kasumi_auth_cipher(
6893                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6894 }
6895
6896 static int
6897 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6898 {
6899         return test_kasumi_auth_cipher(
6900                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6901 }
6902
6903 static int
6904 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6905 {
6906         return test_kasumi_auth_cipher_sgl(
6907                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6908 }
6909
6910 static int
6911 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6912 {
6913         return test_kasumi_auth_cipher_sgl(
6914                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6915 }
6916
6917 static int
6918 test_kasumi_cipher_auth_test_case_1(void)
6919 {
6920         return test_kasumi_cipher_auth(&kasumi_test_case_6);
6921 }
6922
6923 static int
6924 test_zuc_encryption_test_case_1(void)
6925 {
6926         return test_zuc_encryption(&zuc_test_case_cipher_193b);
6927 }
6928
6929 static int
6930 test_zuc_encryption_test_case_2(void)
6931 {
6932         return test_zuc_encryption(&zuc_test_case_cipher_800b);
6933 }
6934
6935 static int
6936 test_zuc_encryption_test_case_3(void)
6937 {
6938         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6939 }
6940
6941 static int
6942 test_zuc_encryption_test_case_4(void)
6943 {
6944         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6945 }
6946
6947 static int
6948 test_zuc_encryption_test_case_5(void)
6949 {
6950         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6951 }
6952
6953 static int
6954 test_zuc_encryption_test_case_6_sgl(void)
6955 {
6956         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6957 }
6958
6959 static int
6960 test_zuc_hash_generate_test_case_1(void)
6961 {
6962         return test_zuc_authentication(&zuc_test_case_auth_1b);
6963 }
6964
6965 static int
6966 test_zuc_hash_generate_test_case_2(void)
6967 {
6968         return test_zuc_authentication(&zuc_test_case_auth_90b);
6969 }
6970
6971 static int
6972 test_zuc_hash_generate_test_case_3(void)
6973 {
6974         return test_zuc_authentication(&zuc_test_case_auth_577b);
6975 }
6976
6977 static int
6978 test_zuc_hash_generate_test_case_4(void)
6979 {
6980         return test_zuc_authentication(&zuc_test_case_auth_2079b);
6981 }
6982
6983 static int
6984 test_zuc_hash_generate_test_case_5(void)
6985 {
6986         return test_zuc_authentication(&zuc_test_auth_5670b);
6987 }
6988
6989 static int
6990 test_zuc_hash_generate_test_case_6(void)
6991 {
6992         return test_zuc_authentication(&zuc_test_case_auth_128b);
6993 }
6994
6995 static int
6996 test_zuc_hash_generate_test_case_7(void)
6997 {
6998         return test_zuc_authentication(&zuc_test_case_auth_2080b);
6999 }
7000
7001 static int
7002 test_zuc_hash_generate_test_case_8(void)
7003 {
7004         return test_zuc_authentication(&zuc_test_case_auth_584b);
7005 }
7006
7007 static int
7008 test_zuc_cipher_auth_test_case_1(void)
7009 {
7010         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7011 }
7012
7013 static int
7014 test_zuc_cipher_auth_test_case_2(void)
7015 {
7016         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7017 }
7018
7019 static int
7020 test_zuc_auth_cipher_test_case_1(void)
7021 {
7022         return test_zuc_auth_cipher(
7023                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7024 }
7025
7026 static int
7027 test_zuc_auth_cipher_test_case_1_oop(void)
7028 {
7029         return test_zuc_auth_cipher(
7030                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7031 }
7032
7033 static int
7034 test_zuc_auth_cipher_test_case_1_sgl(void)
7035 {
7036         return test_zuc_auth_cipher_sgl(
7037                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7038 }
7039
7040 static int
7041 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7042 {
7043         return test_zuc_auth_cipher_sgl(
7044                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7045 }
7046
7047 static int
7048 test_zuc_auth_cipher_verify_test_case_1(void)
7049 {
7050         return test_zuc_auth_cipher(
7051                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7052 }
7053
7054 static int
7055 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7056 {
7057         return test_zuc_auth_cipher(
7058                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7059 }
7060
7061 static int
7062 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7063 {
7064         return test_zuc_auth_cipher_sgl(
7065                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7066 }
7067
7068 static int
7069 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7070 {
7071         return test_zuc_auth_cipher_sgl(
7072                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7073 }
7074
7075 static int
7076 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7077 {
7078         uint8_t dev_id = testsuite_params.valid_devs[0];
7079
7080         struct rte_cryptodev_sym_capability_idx cap_idx;
7081
7082         /* Check if device supports particular cipher algorithm */
7083         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7084         cap_idx.algo.cipher = tdata->cipher_algo;
7085         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7086                 return TEST_SKIPPED;
7087
7088         /* Check if device supports particular hash algorithm */
7089         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7090         cap_idx.algo.auth = tdata->auth_algo;
7091         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7092                 return TEST_SKIPPED;
7093
7094         return 0;
7095 }
7096
7097 static int
7098 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7099         uint8_t op_mode, uint8_t verify)
7100 {
7101         struct crypto_testsuite_params *ts_params = &testsuite_params;
7102         struct crypto_unittest_params *ut_params = &unittest_params;
7103
7104         int retval;
7105
7106         uint8_t *plaintext = NULL, *ciphertext = NULL;
7107         unsigned int plaintext_pad_len;
7108         unsigned int plaintext_len;
7109         unsigned int ciphertext_pad_len;
7110         unsigned int ciphertext_len;
7111
7112         struct rte_cryptodev_info dev_info;
7113         struct rte_crypto_op *op;
7114
7115         /* Check if device supports particular algorithms separately */
7116         if (test_mixed_check_if_unsupported(tdata))
7117                 return TEST_SKIPPED;
7118         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7119                 return TEST_SKIPPED;
7120
7121         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7122
7123         uint64_t feat_flags = dev_info.feature_flags;
7124
7125         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7126                 printf("Device doesn't support digest encrypted.\n");
7127                 return TEST_SKIPPED;
7128         }
7129
7130         /* Create the session */
7131         if (verify)
7132                 retval = create_wireless_algo_cipher_auth_session(
7133                                 ts_params->valid_devs[0],
7134                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7135                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7136                                 tdata->auth_algo,
7137                                 tdata->cipher_algo,
7138                                 tdata->auth_key.data, tdata->auth_key.len,
7139                                 tdata->auth_iv.len, tdata->digest_enc.len,
7140                                 tdata->cipher_iv.len);
7141         else
7142                 retval = create_wireless_algo_auth_cipher_session(
7143                                 ts_params->valid_devs[0],
7144                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7145                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7146                                 tdata->auth_algo,
7147                                 tdata->cipher_algo,
7148                                 tdata->auth_key.data, tdata->auth_key.len,
7149                                 tdata->auth_iv.len, tdata->digest_enc.len,
7150                                 tdata->cipher_iv.len);
7151         if (retval != 0)
7152                 return retval;
7153
7154         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7155         if (op_mode == OUT_OF_PLACE)
7156                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7157
7158         /* clear mbuf payload */
7159         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7160                 rte_pktmbuf_tailroom(ut_params->ibuf));
7161         if (op_mode == OUT_OF_PLACE) {
7162
7163                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7164                                 rte_pktmbuf_tailroom(ut_params->obuf));
7165         }
7166
7167         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7168         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7169         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7170         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7171
7172         if (verify) {
7173                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7174                                 ciphertext_pad_len);
7175                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7176                 if (op_mode == OUT_OF_PLACE)
7177                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7178                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7179                                 ciphertext_len);
7180         } else {
7181                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7182                                 plaintext_pad_len);
7183                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7184                 if (op_mode == OUT_OF_PLACE)
7185                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
7186                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7187         }
7188
7189         /* Create the operation */
7190         retval = create_wireless_algo_auth_cipher_operation(
7191                         tdata->digest_enc.data, tdata->digest_enc.len,
7192                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7193                         tdata->auth_iv.data, tdata->auth_iv.len,
7194                         (tdata->digest_enc.offset == 0 ?
7195                                 plaintext_pad_len
7196                                 : tdata->digest_enc.offset),
7197                         tdata->validCipherLen.len_bits,
7198                         tdata->cipher.offset_bits,
7199                         tdata->validAuthLen.len_bits,
7200                         tdata->auth.offset_bits,
7201                         op_mode, 0, verify);
7202
7203         if (retval < 0)
7204                 return retval;
7205
7206         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7207
7208         /* Check if the op failed because the device doesn't */
7209         /* support this particular combination of algorithms */
7210         if (op == NULL && ut_params->op->status ==
7211                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7212                 printf("Device doesn't support this mixed combination. "
7213                                 "Test Skipped.\n");
7214                 return TEST_SKIPPED;
7215         }
7216         ut_params->op = op;
7217
7218         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7219
7220         ut_params->obuf = (op_mode == IN_PLACE ?
7221                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7222
7223         if (verify) {
7224                 if (ut_params->obuf)
7225                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7226                                                         uint8_t *);
7227                 else
7228                         plaintext = ciphertext +
7229                                         (tdata->cipher.offset_bits >> 3);
7230
7231                 debug_hexdump(stdout, "plaintext:", plaintext,
7232                                 tdata->plaintext.len_bits >> 3);
7233                 debug_hexdump(stdout, "plaintext expected:",
7234                                 tdata->plaintext.data,
7235                                 tdata->plaintext.len_bits >> 3);
7236         } else {
7237                 if (ut_params->obuf)
7238                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7239                                         uint8_t *);
7240                 else
7241                         ciphertext = plaintext;
7242
7243                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7244                                 ciphertext_len);
7245                 debug_hexdump(stdout, "ciphertext expected:",
7246                                 tdata->ciphertext.data,
7247                                 tdata->ciphertext.len_bits >> 3);
7248
7249                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7250                                 + (tdata->digest_enc.offset == 0 ?
7251                 plaintext_pad_len : tdata->digest_enc.offset);
7252
7253                 debug_hexdump(stdout, "digest:", ut_params->digest,
7254                                 tdata->digest_enc.len);
7255                 debug_hexdump(stdout, "digest expected:",
7256                                 tdata->digest_enc.data,
7257                                 tdata->digest_enc.len);
7258         }
7259
7260         /* Validate obuf */
7261         if (verify) {
7262                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7263                                 plaintext,
7264                                 tdata->plaintext.data,
7265                                 tdata->plaintext.len_bits >> 3,
7266                                 "Plaintext data not as expected");
7267         } else {
7268                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7269                                 ciphertext,
7270                                 tdata->ciphertext.data,
7271                                 tdata->validDataLen.len_bits,
7272                                 "Ciphertext data not as expected");
7273
7274                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7275                                 ut_params->digest,
7276                                 tdata->digest_enc.data,
7277                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
7278                                 "Generated auth tag not as expected");
7279         }
7280
7281         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7282                         "crypto op processing failed");
7283
7284         return 0;
7285 }
7286
7287 static int
7288 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7289         uint8_t op_mode, uint8_t verify)
7290 {
7291         struct crypto_testsuite_params *ts_params = &testsuite_params;
7292         struct crypto_unittest_params *ut_params = &unittest_params;
7293
7294         int retval;
7295
7296         const uint8_t *plaintext = NULL;
7297         const uint8_t *ciphertext = NULL;
7298         const uint8_t *digest = NULL;
7299         unsigned int plaintext_pad_len;
7300         unsigned int plaintext_len;
7301         unsigned int ciphertext_pad_len;
7302         unsigned int ciphertext_len;
7303         uint8_t buffer[10000];
7304         uint8_t digest_buffer[10000];
7305
7306         struct rte_cryptodev_info dev_info;
7307         struct rte_crypto_op *op;
7308
7309         /* Check if device supports particular algorithms */
7310         if (test_mixed_check_if_unsupported(tdata))
7311                 return TEST_SKIPPED;
7312         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7313                 return TEST_SKIPPED;
7314
7315         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7316
7317         uint64_t feat_flags = dev_info.feature_flags;
7318
7319         if (op_mode == IN_PLACE) {
7320                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7321                         printf("Device doesn't support in-place scatter-gather "
7322                                         "in both input and output mbufs.\n");
7323                         return TEST_SKIPPED;
7324                 }
7325         } else {
7326                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7327                         printf("Device doesn't support out-of-place scatter-gather "
7328                                         "in both input and output mbufs.\n");
7329                         return TEST_SKIPPED;
7330                 }
7331                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7332                         printf("Device doesn't support digest encrypted.\n");
7333                         return TEST_SKIPPED;
7334                 }
7335         }
7336
7337         /* Create the session */
7338         if (verify)
7339                 retval = create_wireless_algo_cipher_auth_session(
7340                                 ts_params->valid_devs[0],
7341                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7342                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7343                                 tdata->auth_algo,
7344                                 tdata->cipher_algo,
7345                                 tdata->auth_key.data, tdata->auth_key.len,
7346                                 tdata->auth_iv.len, tdata->digest_enc.len,
7347                                 tdata->cipher_iv.len);
7348         else
7349                 retval = create_wireless_algo_auth_cipher_session(
7350                                 ts_params->valid_devs[0],
7351                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7352                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7353                                 tdata->auth_algo,
7354                                 tdata->cipher_algo,
7355                                 tdata->auth_key.data, tdata->auth_key.len,
7356                                 tdata->auth_iv.len, tdata->digest_enc.len,
7357                                 tdata->cipher_iv.len);
7358         if (retval != 0)
7359                 return retval;
7360
7361         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7362         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7363         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7364         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7365
7366         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7367                         ciphertext_pad_len, 15, 0);
7368         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7369                         "Failed to allocate input buffer in mempool");
7370
7371         if (op_mode == OUT_OF_PLACE) {
7372                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7373                                 plaintext_pad_len, 15, 0);
7374                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7375                                 "Failed to allocate output buffer in mempool");
7376         }
7377
7378         if (verify) {
7379                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7380                         tdata->ciphertext.data);
7381                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7382                                         ciphertext_len, buffer);
7383                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7384                         ciphertext_len);
7385         } else {
7386                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7387                         tdata->plaintext.data);
7388                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7389                                         plaintext_len, buffer);
7390                 debug_hexdump(stdout, "plaintext:", plaintext,
7391                         plaintext_len);
7392         }
7393         memset(buffer, 0, sizeof(buffer));
7394
7395         /* Create the operation */
7396         retval = create_wireless_algo_auth_cipher_operation(
7397                         tdata->digest_enc.data, tdata->digest_enc.len,
7398                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7399                         tdata->auth_iv.data, tdata->auth_iv.len,
7400                         (tdata->digest_enc.offset == 0 ?
7401                                 plaintext_pad_len
7402                                 : tdata->digest_enc.offset),
7403                         tdata->validCipherLen.len_bits,
7404                         tdata->cipher.offset_bits,
7405                         tdata->validAuthLen.len_bits,
7406                         tdata->auth.offset_bits,
7407                         op_mode, 1, verify);
7408
7409         if (retval < 0)
7410                 return retval;
7411
7412         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7413
7414         /* Check if the op failed because the device doesn't */
7415         /* support this particular combination of algorithms */
7416         if (op == NULL && ut_params->op->status ==
7417                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7418                 printf("Device doesn't support this mixed combination. "
7419                                 "Test Skipped.\n");
7420                 return TEST_SKIPPED;
7421         }
7422         ut_params->op = op;
7423
7424         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7425
7426         ut_params->obuf = (op_mode == IN_PLACE ?
7427                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7428
7429         if (verify) {
7430                 if (ut_params->obuf)
7431                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7432                                         plaintext_len, buffer);
7433                 else
7434                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7435                                         plaintext_len, buffer);
7436
7437                 debug_hexdump(stdout, "plaintext:", plaintext,
7438                                 (tdata->plaintext.len_bits >> 3) -
7439                                 tdata->digest_enc.len);
7440                 debug_hexdump(stdout, "plaintext expected:",
7441                                 tdata->plaintext.data,
7442                                 (tdata->plaintext.len_bits >> 3) -
7443                                 tdata->digest_enc.len);
7444         } else {
7445                 if (ut_params->obuf)
7446                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7447                                         ciphertext_len, buffer);
7448                 else
7449                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7450                                         ciphertext_len, buffer);
7451
7452                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7453                         ciphertext_len);
7454                 debug_hexdump(stdout, "ciphertext expected:",
7455                         tdata->ciphertext.data,
7456                         tdata->ciphertext.len_bits >> 3);
7457
7458                 if (ut_params->obuf)
7459                         digest = rte_pktmbuf_read(ut_params->obuf,
7460                                         (tdata->digest_enc.offset == 0 ?
7461                                                 plaintext_pad_len :
7462                                                 tdata->digest_enc.offset),
7463                                         tdata->digest_enc.len, digest_buffer);
7464                 else
7465                         digest = rte_pktmbuf_read(ut_params->ibuf,
7466                                         (tdata->digest_enc.offset == 0 ?
7467                                                 plaintext_pad_len :
7468                                                 tdata->digest_enc.offset),
7469                                         tdata->digest_enc.len, digest_buffer);
7470
7471                 debug_hexdump(stdout, "digest:", digest,
7472                                 tdata->digest_enc.len);
7473                 debug_hexdump(stdout, "digest expected:",
7474                                 tdata->digest_enc.data, tdata->digest_enc.len);
7475         }
7476
7477         /* Validate obuf */
7478         if (verify) {
7479                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7480                                 plaintext,
7481                                 tdata->plaintext.data,
7482                                 tdata->plaintext.len_bits >> 3,
7483                                 "Plaintext data not as expected");
7484         } else {
7485                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7486                                 ciphertext,
7487                                 tdata->ciphertext.data,
7488                                 tdata->validDataLen.len_bits,
7489                                 "Ciphertext data not as expected");
7490                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7491                                 digest,
7492                                 tdata->digest_enc.data,
7493                                 tdata->digest_enc.len,
7494                                 "Generated auth tag not as expected");
7495         }
7496
7497         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7498                         "crypto op processing failed");
7499
7500         return 0;
7501 }
7502
7503 /** AUTH AES CMAC + CIPHER AES CTR */
7504
7505 static int
7506 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7507 {
7508         return test_mixed_auth_cipher(
7509                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7510 }
7511
7512 static int
7513 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7514 {
7515         return test_mixed_auth_cipher(
7516                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7517 }
7518
7519 static int
7520 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7521 {
7522         return test_mixed_auth_cipher_sgl(
7523                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7524 }
7525
7526 static int
7527 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7528 {
7529         return test_mixed_auth_cipher_sgl(
7530                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7531 }
7532
7533 static int
7534 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7535 {
7536         return test_mixed_auth_cipher(
7537                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7538 }
7539
7540 static int
7541 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7542 {
7543         return test_mixed_auth_cipher(
7544                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7545 }
7546
7547 static int
7548 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7549 {
7550         return test_mixed_auth_cipher_sgl(
7551                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7552 }
7553
7554 static int
7555 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7556 {
7557         return test_mixed_auth_cipher_sgl(
7558                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7559 }
7560
7561 /** MIXED AUTH + CIPHER */
7562
7563 static int
7564 test_auth_zuc_cipher_snow_test_case_1(void)
7565 {
7566         return test_mixed_auth_cipher(
7567                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7568 }
7569
7570 static int
7571 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7572 {
7573         return test_mixed_auth_cipher(
7574                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7575 }
7576
7577 static int
7578 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7579 {
7580         return test_mixed_auth_cipher(
7581                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7582 }
7583
7584 static int
7585 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7586 {
7587         return test_mixed_auth_cipher(
7588                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7589 }
7590
7591 static int
7592 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7593 {
7594         return test_mixed_auth_cipher(
7595                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7596 }
7597
7598 static int
7599 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7600 {
7601         return test_mixed_auth_cipher(
7602                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7603 }
7604
7605 static int
7606 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7607 {
7608         return test_mixed_auth_cipher(
7609                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7610 }
7611
7612 static int
7613 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7614 {
7615         return test_mixed_auth_cipher(
7616                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7617 }
7618
7619 static int
7620 test_auth_snow_cipher_zuc_test_case_1(void)
7621 {
7622         return test_mixed_auth_cipher(
7623                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7624 }
7625
7626 static int
7627 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7628 {
7629         return test_mixed_auth_cipher(
7630                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7631 }
7632
7633 static int
7634 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7635 {
7636         return test_mixed_auth_cipher(
7637                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7638 }
7639
7640 static int
7641 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7642 {
7643         return test_mixed_auth_cipher(
7644                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7645 }
7646
7647 static int
7648 test_auth_null_cipher_snow_test_case_1(void)
7649 {
7650         return test_mixed_auth_cipher(
7651                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7652 }
7653
7654 static int
7655 test_verify_auth_null_cipher_snow_test_case_1(void)
7656 {
7657         return test_mixed_auth_cipher(
7658                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7659 }
7660
7661 static int
7662 test_auth_null_cipher_zuc_test_case_1(void)
7663 {
7664         return test_mixed_auth_cipher(
7665                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7666 }
7667
7668 static int
7669 test_verify_auth_null_cipher_zuc_test_case_1(void)
7670 {
7671         return test_mixed_auth_cipher(
7672                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7673 }
7674
7675 static int
7676 test_auth_snow_cipher_null_test_case_1(void)
7677 {
7678         return test_mixed_auth_cipher(
7679                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7680 }
7681
7682 static int
7683 test_verify_auth_snow_cipher_null_test_case_1(void)
7684 {
7685         return test_mixed_auth_cipher(
7686                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7687 }
7688
7689 static int
7690 test_auth_zuc_cipher_null_test_case_1(void)
7691 {
7692         return test_mixed_auth_cipher(
7693                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7694 }
7695
7696 static int
7697 test_verify_auth_zuc_cipher_null_test_case_1(void)
7698 {
7699         return test_mixed_auth_cipher(
7700                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7701 }
7702
7703 static int
7704 test_auth_null_cipher_aes_ctr_test_case_1(void)
7705 {
7706         return test_mixed_auth_cipher(
7707                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7708 }
7709
7710 static int
7711 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7712 {
7713         return test_mixed_auth_cipher(
7714                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7715 }
7716
7717 static int
7718 test_auth_aes_cmac_cipher_null_test_case_1(void)
7719 {
7720         return test_mixed_auth_cipher(
7721                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7722 }
7723
7724 static int
7725 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7726 {
7727         return test_mixed_auth_cipher(
7728                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7729 }
7730
7731 /* ***** AEAD algorithm Tests ***** */
7732
7733 static int
7734 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7735                 enum rte_crypto_aead_operation op,
7736                 const uint8_t *key, const uint8_t key_len,
7737                 const uint16_t aad_len, const uint8_t auth_len,
7738                 uint8_t iv_len)
7739 {
7740         uint8_t aead_key[key_len];
7741
7742         struct crypto_testsuite_params *ts_params = &testsuite_params;
7743         struct crypto_unittest_params *ut_params = &unittest_params;
7744
7745         memcpy(aead_key, key, key_len);
7746
7747         /* Setup AEAD Parameters */
7748         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7749         ut_params->aead_xform.next = NULL;
7750         ut_params->aead_xform.aead.algo = algo;
7751         ut_params->aead_xform.aead.op = op;
7752         ut_params->aead_xform.aead.key.data = aead_key;
7753         ut_params->aead_xform.aead.key.length = key_len;
7754         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7755         ut_params->aead_xform.aead.iv.length = iv_len;
7756         ut_params->aead_xform.aead.digest_length = auth_len;
7757         ut_params->aead_xform.aead.aad_length = aad_len;
7758
7759         debug_hexdump(stdout, "key:", key, key_len);
7760
7761         /* Create Crypto session*/
7762         ut_params->sess = rte_cryptodev_sym_session_create(
7763                         ts_params->session_mpool);
7764
7765         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7766                         &ut_params->aead_xform,
7767                         ts_params->session_priv_mpool);
7768
7769         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7770
7771         return 0;
7772 }
7773
7774 static int
7775 create_aead_xform(struct rte_crypto_op *op,
7776                 enum rte_crypto_aead_algorithm algo,
7777                 enum rte_crypto_aead_operation aead_op,
7778                 uint8_t *key, const uint8_t key_len,
7779                 const uint8_t aad_len, const uint8_t auth_len,
7780                 uint8_t iv_len)
7781 {
7782         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7783                         "failed to allocate space for crypto transform");
7784
7785         struct rte_crypto_sym_op *sym_op = op->sym;
7786
7787         /* Setup AEAD Parameters */
7788         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7789         sym_op->xform->next = NULL;
7790         sym_op->xform->aead.algo = algo;
7791         sym_op->xform->aead.op = aead_op;
7792         sym_op->xform->aead.key.data = key;
7793         sym_op->xform->aead.key.length = key_len;
7794         sym_op->xform->aead.iv.offset = IV_OFFSET;
7795         sym_op->xform->aead.iv.length = iv_len;
7796         sym_op->xform->aead.digest_length = auth_len;
7797         sym_op->xform->aead.aad_length = aad_len;
7798
7799         debug_hexdump(stdout, "key:", key, key_len);
7800
7801         return 0;
7802 }
7803
7804 static int
7805 create_aead_operation(enum rte_crypto_aead_operation op,
7806                 const struct aead_test_data *tdata)
7807 {
7808         struct crypto_testsuite_params *ts_params = &testsuite_params;
7809         struct crypto_unittest_params *ut_params = &unittest_params;
7810
7811         uint8_t *plaintext, *ciphertext;
7812         unsigned int aad_pad_len, plaintext_pad_len;
7813
7814         /* Generate Crypto op data structure */
7815         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7816                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7817         TEST_ASSERT_NOT_NULL(ut_params->op,
7818                         "Failed to allocate symmetric crypto operation struct");
7819
7820         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7821
7822         /* Append aad data */
7823         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7824                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7825                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7826                                 aad_pad_len);
7827                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7828                                 "no room to append aad");
7829
7830                 sym_op->aead.aad.phys_addr =
7831                                 rte_pktmbuf_iova(ut_params->ibuf);
7832                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7833                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7834                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7835                         tdata->aad.len);
7836
7837                 /* Append IV at the end of the crypto operation*/
7838                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7839                                 uint8_t *, IV_OFFSET);
7840
7841                 /* Copy IV 1 byte after the IV pointer, according to the API */
7842                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7843                 debug_hexdump(stdout, "iv:", iv_ptr,
7844                         tdata->iv.len);
7845         } else {
7846                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7847                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7848                                 aad_pad_len);
7849                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7850                                 "no room to append aad");
7851
7852                 sym_op->aead.aad.phys_addr =
7853                                 rte_pktmbuf_iova(ut_params->ibuf);
7854                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7855                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7856                         tdata->aad.len);
7857
7858                 /* Append IV at the end of the crypto operation*/
7859                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7860                                 uint8_t *, IV_OFFSET);
7861
7862                 if (tdata->iv.len == 0) {
7863                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7864                         debug_hexdump(stdout, "iv:", iv_ptr,
7865                                 AES_GCM_J0_LENGTH);
7866                 } else {
7867                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7868                         debug_hexdump(stdout, "iv:", iv_ptr,
7869                                 tdata->iv.len);
7870                 }
7871         }
7872
7873         /* Append plaintext/ciphertext */
7874         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7875                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7876                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7877                                 plaintext_pad_len);
7878                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7879
7880                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7881                 debug_hexdump(stdout, "plaintext:", plaintext,
7882                                 tdata->plaintext.len);
7883
7884                 if (ut_params->obuf) {
7885                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7886                                         ut_params->obuf,
7887                                         plaintext_pad_len + aad_pad_len);
7888                         TEST_ASSERT_NOT_NULL(ciphertext,
7889                                         "no room to append ciphertext");
7890
7891                         memset(ciphertext + aad_pad_len, 0,
7892                                         tdata->ciphertext.len);
7893                 }
7894         } else {
7895                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7896                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7897                                 plaintext_pad_len);
7898                 TEST_ASSERT_NOT_NULL(ciphertext,
7899                                 "no room to append ciphertext");
7900
7901                 memcpy(ciphertext, tdata->ciphertext.data,
7902                                 tdata->ciphertext.len);
7903                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7904                                 tdata->ciphertext.len);
7905
7906                 if (ut_params->obuf) {
7907                         plaintext = (uint8_t *)rte_pktmbuf_append(
7908                                         ut_params->obuf,
7909                                         plaintext_pad_len + aad_pad_len);
7910                         TEST_ASSERT_NOT_NULL(plaintext,
7911                                         "no room to append plaintext");
7912
7913                         memset(plaintext + aad_pad_len, 0,
7914                                         tdata->plaintext.len);
7915                 }
7916         }
7917
7918         /* Append digest data */
7919         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7920                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7921                                 ut_params->obuf ? ut_params->obuf :
7922                                                 ut_params->ibuf,
7923                                                 tdata->auth_tag.len);
7924                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7925                                 "no room to append digest");
7926                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7927                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7928                                 ut_params->obuf ? ut_params->obuf :
7929                                                 ut_params->ibuf,
7930                                                 plaintext_pad_len +
7931                                                 aad_pad_len);
7932         } else {
7933                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7934                                 ut_params->ibuf, tdata->auth_tag.len);
7935                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7936                                 "no room to append digest");
7937                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7938                                 ut_params->ibuf,
7939                                 plaintext_pad_len + aad_pad_len);
7940
7941                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7942                         tdata->auth_tag.len);
7943                 debug_hexdump(stdout, "digest:",
7944                         sym_op->aead.digest.data,
7945                         tdata->auth_tag.len);
7946         }
7947
7948         sym_op->aead.data.length = tdata->plaintext.len;
7949         sym_op->aead.data.offset = aad_pad_len;
7950
7951         return 0;
7952 }
7953
7954 static int
7955 test_authenticated_encryption(const struct aead_test_data *tdata)
7956 {
7957         struct crypto_testsuite_params *ts_params = &testsuite_params;
7958         struct crypto_unittest_params *ut_params = &unittest_params;
7959
7960         int retval;
7961         uint8_t *ciphertext, *auth_tag;
7962         uint16_t plaintext_pad_len;
7963         uint32_t i;
7964         struct rte_cryptodev_info dev_info;
7965
7966         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7967         uint64_t feat_flags = dev_info.feature_flags;
7968
7969         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
7970                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
7971                 printf("Device doesn't support RAW data-path APIs.\n");
7972                 return TEST_SKIPPED;
7973         }
7974
7975         /* Verify the capabilities */
7976         struct rte_cryptodev_sym_capability_idx cap_idx;
7977         const struct rte_cryptodev_symmetric_capability *capability;
7978         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7979         cap_idx.algo.aead = tdata->algo;
7980         capability = rte_cryptodev_sym_capability_get(
7981                         ts_params->valid_devs[0], &cap_idx);
7982         if (capability == NULL)
7983                 return TEST_SKIPPED;
7984         if (rte_cryptodev_sym_capability_check_aead(
7985                         capability, tdata->key.len, tdata->auth_tag.len,
7986                         tdata->aad.len, tdata->iv.len))
7987                 return TEST_SKIPPED;
7988
7989         /* Create AEAD session */
7990         retval = create_aead_session(ts_params->valid_devs[0],
7991                         tdata->algo,
7992                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7993                         tdata->key.data, tdata->key.len,
7994                         tdata->aad.len, tdata->auth_tag.len,
7995                         tdata->iv.len);
7996         if (retval < 0)
7997                 return retval;
7998
7999         if (tdata->aad.len > MBUF_SIZE) {
8000                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8001                 /* Populate full size of add data */
8002                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8003                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8004         } else
8005                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8006
8007         /* clear mbuf payload */
8008         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8009                         rte_pktmbuf_tailroom(ut_params->ibuf));
8010
8011         /* Create AEAD operation */
8012         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8013         if (retval < 0)
8014                 return retval;
8015
8016         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8017
8018         ut_params->op->sym->m_src = ut_params->ibuf;
8019
8020         /* Process crypto operation */
8021         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8022                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8023         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8024                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8025                                 ut_params->op, 0, 0, 0, 0);
8026         else
8027                 TEST_ASSERT_NOT_NULL(
8028                         process_crypto_request(ts_params->valid_devs[0],
8029                         ut_params->op), "failed to process sym crypto op");
8030
8031         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8032                         "crypto op processing failed");
8033
8034         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8035
8036         if (ut_params->op->sym->m_dst) {
8037                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8038                                 uint8_t *);
8039                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8040                                 uint8_t *, plaintext_pad_len);
8041         } else {
8042                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8043                                 uint8_t *,
8044                                 ut_params->op->sym->cipher.data.offset);
8045                 auth_tag = ciphertext + plaintext_pad_len;
8046         }
8047
8048         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8049         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8050
8051         /* Validate obuf */
8052         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8053                         ciphertext,
8054                         tdata->ciphertext.data,
8055                         tdata->ciphertext.len,
8056                         "Ciphertext data not as expected");
8057
8058         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8059                         auth_tag,
8060                         tdata->auth_tag.data,
8061                         tdata->auth_tag.len,
8062                         "Generated auth tag not as expected");
8063
8064         return 0;
8065
8066 }
8067
8068 #ifdef RTE_LIB_SECURITY
8069 static int
8070 security_proto_supported(enum rte_security_session_action_type action,
8071         enum rte_security_session_protocol proto)
8072 {
8073         struct crypto_testsuite_params *ts_params = &testsuite_params;
8074
8075         const struct rte_security_capability *capabilities;
8076         const struct rte_security_capability *capability;
8077         uint16_t i = 0;
8078
8079         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8080                                 rte_cryptodev_get_sec_ctx(
8081                                 ts_params->valid_devs[0]);
8082
8083
8084         capabilities = rte_security_capabilities_get(ctx);
8085
8086         if (capabilities == NULL)
8087                 return -ENOTSUP;
8088
8089         while ((capability = &capabilities[i++])->action !=
8090                         RTE_SECURITY_ACTION_TYPE_NONE) {
8091                 if (capability->action == action &&
8092                                 capability->protocol == proto)
8093                         return 0;
8094         }
8095
8096         return -ENOTSUP;
8097 }
8098
8099 /* Basic algorithm run function for async inplace mode.
8100  * Creates a session from input parameters and runs one operation
8101  * on input_vec. Checks the output of the crypto operation against
8102  * output_vec.
8103  */
8104 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8105                            enum rte_crypto_auth_operation opa,
8106                            const uint8_t *input_vec, unsigned int input_vec_len,
8107                            const uint8_t *output_vec,
8108                            unsigned int output_vec_len,
8109                            enum rte_crypto_cipher_algorithm cipher_alg,
8110                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8111                            enum rte_crypto_auth_algorithm auth_alg,
8112                            const uint8_t *auth_key, uint32_t auth_key_len,
8113                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8114                            uint8_t packet_direction, uint8_t sn_size,
8115                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8116 {
8117         struct crypto_testsuite_params *ts_params = &testsuite_params;
8118         struct crypto_unittest_params *ut_params = &unittest_params;
8119         uint8_t *plaintext;
8120         int ret = TEST_SUCCESS;
8121         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8122                                 rte_cryptodev_get_sec_ctx(
8123                                 ts_params->valid_devs[0]);
8124
8125         /* Verify the capabilities */
8126         struct rte_security_capability_idx sec_cap_idx;
8127
8128         sec_cap_idx.action = ut_params->type;
8129         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8130         sec_cap_idx.pdcp.domain = domain;
8131         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8132                 return TEST_SKIPPED;
8133
8134         /* Generate test mbuf data */
8135         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8136
8137         /* clear mbuf payload */
8138         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8139                         rte_pktmbuf_tailroom(ut_params->ibuf));
8140
8141         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8142                                                   input_vec_len);
8143         memcpy(plaintext, input_vec, input_vec_len);
8144
8145         /* Out of place support */
8146         if (oop) {
8147                 /*
8148                  * For out-op-place we need to alloc another mbuf
8149                  */
8150                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8151                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8152         }
8153
8154         /* Setup Cipher Parameters */
8155         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8156         ut_params->cipher_xform.cipher.algo = cipher_alg;
8157         ut_params->cipher_xform.cipher.op = opc;
8158         ut_params->cipher_xform.cipher.key.data = cipher_key;
8159         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8160         ut_params->cipher_xform.cipher.iv.length =
8161                                 packet_direction ? 4 : 0;
8162         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8163
8164         /* Setup HMAC Parameters if ICV header is required */
8165         if (auth_alg != 0) {
8166                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8167                 ut_params->auth_xform.next = NULL;
8168                 ut_params->auth_xform.auth.algo = auth_alg;
8169                 ut_params->auth_xform.auth.op = opa;
8170                 ut_params->auth_xform.auth.key.data = auth_key;
8171                 ut_params->auth_xform.auth.key.length = auth_key_len;
8172
8173                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8174         } else {
8175                 ut_params->cipher_xform.next = NULL;
8176         }
8177
8178         struct rte_security_session_conf sess_conf = {
8179                 .action_type = ut_params->type,
8180                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8181                 {.pdcp = {
8182                         .bearer = bearer,
8183                         .domain = domain,
8184                         .pkt_dir = packet_direction,
8185                         .sn_size = sn_size,
8186                         .hfn = packet_direction ? 0 : hfn,
8187                         /**
8188                          * hfn can be set as pdcp_test_hfn[i]
8189                          * if hfn_ovrd is not set. Here, PDCP
8190                          * packet direction is just used to
8191                          * run half of the cases with session
8192                          * HFN and other half with per packet
8193                          * HFN.
8194                          */
8195                         .hfn_threshold = hfn_threshold,
8196                         .hfn_ovrd = packet_direction ? 1 : 0,
8197                         .sdap_enabled = sdap,
8198                 } },
8199                 .crypto_xform = &ut_params->cipher_xform
8200         };
8201
8202         /* Create security session */
8203         ut_params->sec_session = rte_security_session_create(ctx,
8204                                 &sess_conf, ts_params->session_mpool,
8205                                 ts_params->session_priv_mpool);
8206
8207         if (!ut_params->sec_session) {
8208                 printf("TestCase %s()-%d line %d failed %s: ",
8209                         __func__, i, __LINE__, "Failed to allocate session");
8210                 ret = TEST_FAILED;
8211                 goto on_err;
8212         }
8213
8214         /* Generate crypto op data structure */
8215         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8216                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8217         if (!ut_params->op) {
8218                 printf("TestCase %s()-%d line %d failed %s: ",
8219                         __func__, i, __LINE__,
8220                         "Failed to allocate symmetric crypto operation struct");
8221                 ret = TEST_FAILED;
8222                 goto on_err;
8223         }
8224
8225         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8226                                         uint32_t *, IV_OFFSET);
8227         *per_pkt_hfn = packet_direction ? hfn : 0;
8228
8229         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8230
8231         /* set crypto operation source mbuf */
8232         ut_params->op->sym->m_src = ut_params->ibuf;
8233         if (oop)
8234                 ut_params->op->sym->m_dst = ut_params->obuf;
8235
8236         /* Process crypto operation */
8237         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8238                 == NULL) {
8239                 printf("TestCase %s()-%d line %d failed %s: ",
8240                         __func__, i, __LINE__,
8241                         "failed to process sym crypto op");
8242                 ret = TEST_FAILED;
8243                 goto on_err;
8244         }
8245
8246         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8247                 printf("TestCase %s()-%d line %d failed %s: ",
8248                         __func__, i, __LINE__, "crypto op processing failed");
8249                 ret = TEST_FAILED;
8250                 goto on_err;
8251         }
8252
8253         /* Validate obuf */
8254         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8255                         uint8_t *);
8256         if (oop) {
8257                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8258                                 uint8_t *);
8259         }
8260
8261         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8262                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8263                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8264                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8265                 ret = TEST_FAILED;
8266                 goto on_err;
8267         }
8268
8269 on_err:
8270         rte_crypto_op_free(ut_params->op);
8271         ut_params->op = NULL;
8272
8273         if (ut_params->sec_session)
8274                 rte_security_session_destroy(ctx, ut_params->sec_session);
8275         ut_params->sec_session = NULL;
8276
8277         rte_pktmbuf_free(ut_params->ibuf);
8278         ut_params->ibuf = NULL;
8279         if (oop) {
8280                 rte_pktmbuf_free(ut_params->obuf);
8281                 ut_params->obuf = NULL;
8282         }
8283
8284         return ret;
8285 }
8286
8287 static int
8288 test_pdcp_proto_SGL(int i, int oop,
8289         enum rte_crypto_cipher_operation opc,
8290         enum rte_crypto_auth_operation opa,
8291         uint8_t *input_vec,
8292         unsigned int input_vec_len,
8293         uint8_t *output_vec,
8294         unsigned int output_vec_len,
8295         uint32_t fragsz,
8296         uint32_t fragsz_oop)
8297 {
8298         struct crypto_testsuite_params *ts_params = &testsuite_params;
8299         struct crypto_unittest_params *ut_params = &unittest_params;
8300         uint8_t *plaintext;
8301         struct rte_mbuf *buf, *buf_oop = NULL;
8302         int ret = TEST_SUCCESS;
8303         int to_trn = 0;
8304         int to_trn_tbl[16];
8305         int segs = 1;
8306         unsigned int trn_data = 0;
8307         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8308                                 rte_cryptodev_get_sec_ctx(
8309                                 ts_params->valid_devs[0]);
8310
8311         /* Verify the capabilities */
8312         struct rte_security_capability_idx sec_cap_idx;
8313
8314         sec_cap_idx.action = ut_params->type;
8315         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8316         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8317         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8318                 return TEST_SKIPPED;
8319
8320         if (fragsz > input_vec_len)
8321                 fragsz = input_vec_len;
8322
8323         uint16_t plaintext_len = fragsz;
8324         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8325
8326         if (fragsz_oop > output_vec_len)
8327                 frag_size_oop = output_vec_len;
8328
8329         int ecx = 0;
8330         if (input_vec_len % fragsz != 0) {
8331                 if (input_vec_len / fragsz + 1 > 16)
8332                         return 1;
8333         } else if (input_vec_len / fragsz > 16)
8334                 return 1;
8335
8336         /* Out of place support */
8337         if (oop) {
8338                 /*
8339                  * For out-op-place we need to alloc another mbuf
8340                  */
8341                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8342                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8343                 buf_oop = ut_params->obuf;
8344         }
8345
8346         /* Generate test mbuf data */
8347         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8348
8349         /* clear mbuf payload */
8350         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8351                         rte_pktmbuf_tailroom(ut_params->ibuf));
8352
8353         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8354                                                   plaintext_len);
8355         memcpy(plaintext, input_vec, plaintext_len);
8356         trn_data += plaintext_len;
8357
8358         buf = ut_params->ibuf;
8359
8360         /*
8361          * Loop until no more fragments
8362          */
8363
8364         while (trn_data < input_vec_len) {
8365                 ++segs;
8366                 to_trn = (input_vec_len - trn_data < fragsz) ?
8367                                 (input_vec_len - trn_data) : fragsz;
8368
8369                 to_trn_tbl[ecx++] = to_trn;
8370
8371                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8372                 buf = buf->next;
8373
8374                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8375                                 rte_pktmbuf_tailroom(buf));
8376
8377                 /* OOP */
8378                 if (oop && !fragsz_oop) {
8379                         buf_oop->next =
8380                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8381                         buf_oop = buf_oop->next;
8382                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8383                                         0, rte_pktmbuf_tailroom(buf_oop));
8384                         rte_pktmbuf_append(buf_oop, to_trn);
8385                 }
8386
8387                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8388                                 to_trn);
8389
8390                 memcpy(plaintext, input_vec + trn_data, to_trn);
8391                 trn_data += to_trn;
8392         }
8393
8394         ut_params->ibuf->nb_segs = segs;
8395
8396         segs = 1;
8397         if (fragsz_oop && oop) {
8398                 to_trn = 0;
8399                 ecx = 0;
8400
8401                 trn_data = frag_size_oop;
8402                 while (trn_data < output_vec_len) {
8403                         ++segs;
8404                         to_trn =
8405                                 (output_vec_len - trn_data <
8406                                                 frag_size_oop) ?
8407                                 (output_vec_len - trn_data) :
8408                                                 frag_size_oop;
8409
8410                         to_trn_tbl[ecx++] = to_trn;
8411
8412                         buf_oop->next =
8413                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8414                         buf_oop = buf_oop->next;
8415                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8416                                         0, rte_pktmbuf_tailroom(buf_oop));
8417                         rte_pktmbuf_append(buf_oop, to_trn);
8418
8419                         trn_data += to_trn;
8420                 }
8421                 ut_params->obuf->nb_segs = segs;
8422         }
8423
8424         /* Setup Cipher Parameters */
8425         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8426         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8427         ut_params->cipher_xform.cipher.op = opc;
8428         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8429         ut_params->cipher_xform.cipher.key.length =
8430                                         pdcp_test_params[i].cipher_key_len;
8431         ut_params->cipher_xform.cipher.iv.length = 0;
8432
8433         /* Setup HMAC Parameters if ICV header is required */
8434         if (pdcp_test_params[i].auth_alg != 0) {
8435                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8436                 ut_params->auth_xform.next = NULL;
8437                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8438                 ut_params->auth_xform.auth.op = opa;
8439                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8440                 ut_params->auth_xform.auth.key.length =
8441                                         pdcp_test_params[i].auth_key_len;
8442
8443                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8444         } else {
8445                 ut_params->cipher_xform.next = NULL;
8446         }
8447
8448         struct rte_security_session_conf sess_conf = {
8449                 .action_type = ut_params->type,
8450                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8451                 {.pdcp = {
8452                         .bearer = pdcp_test_bearer[i],
8453                         .domain = pdcp_test_params[i].domain,
8454                         .pkt_dir = pdcp_test_packet_direction[i],
8455                         .sn_size = pdcp_test_data_sn_size[i],
8456                         .hfn = pdcp_test_hfn[i],
8457                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8458                         .hfn_ovrd = 0,
8459                 } },
8460                 .crypto_xform = &ut_params->cipher_xform
8461         };
8462
8463         /* Create security session */
8464         ut_params->sec_session = rte_security_session_create(ctx,
8465                                 &sess_conf, ts_params->session_mpool,
8466                                 ts_params->session_priv_mpool);
8467
8468         if (!ut_params->sec_session) {
8469                 printf("TestCase %s()-%d line %d failed %s: ",
8470                         __func__, i, __LINE__, "Failed to allocate session");
8471                 ret = TEST_FAILED;
8472                 goto on_err;
8473         }
8474
8475         /* Generate crypto op data structure */
8476         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8477                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8478         if (!ut_params->op) {
8479                 printf("TestCase %s()-%d line %d failed %s: ",
8480                         __func__, i, __LINE__,
8481                         "Failed to allocate symmetric crypto operation struct");
8482                 ret = TEST_FAILED;
8483                 goto on_err;
8484         }
8485
8486         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8487
8488         /* set crypto operation source mbuf */
8489         ut_params->op->sym->m_src = ut_params->ibuf;
8490         if (oop)
8491                 ut_params->op->sym->m_dst = ut_params->obuf;
8492
8493         /* Process crypto operation */
8494         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8495                 == NULL) {
8496                 printf("TestCase %s()-%d line %d failed %s: ",
8497                         __func__, i, __LINE__,
8498                         "failed to process sym crypto op");
8499                 ret = TEST_FAILED;
8500                 goto on_err;
8501         }
8502
8503         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8504                 printf("TestCase %s()-%d line %d failed %s: ",
8505                         __func__, i, __LINE__, "crypto op processing failed");
8506                 ret = TEST_FAILED;
8507                 goto on_err;
8508         }
8509
8510         /* Validate obuf */
8511         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8512                         uint8_t *);
8513         if (oop) {
8514                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8515                                 uint8_t *);
8516         }
8517         if (fragsz_oop)
8518                 fragsz = frag_size_oop;
8519         if (memcmp(ciphertext, output_vec, fragsz)) {
8520                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8521                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8522                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8523                 ret = TEST_FAILED;
8524                 goto on_err;
8525         }
8526
8527         buf = ut_params->op->sym->m_src->next;
8528         if (oop)
8529                 buf = ut_params->op->sym->m_dst->next;
8530
8531         unsigned int off = fragsz;
8532
8533         ecx = 0;
8534         while (buf) {
8535                 ciphertext = rte_pktmbuf_mtod(buf,
8536                                 uint8_t *);
8537                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8538                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8539                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8540                         rte_hexdump(stdout, "reference", output_vec + off,
8541                                         to_trn_tbl[ecx]);
8542                         ret = TEST_FAILED;
8543                         goto on_err;
8544                 }
8545                 off += to_trn_tbl[ecx++];
8546                 buf = buf->next;
8547         }
8548 on_err:
8549         rte_crypto_op_free(ut_params->op);
8550         ut_params->op = NULL;
8551
8552         if (ut_params->sec_session)
8553                 rte_security_session_destroy(ctx, ut_params->sec_session);
8554         ut_params->sec_session = NULL;
8555
8556         rte_pktmbuf_free(ut_params->ibuf);
8557         ut_params->ibuf = NULL;
8558         if (oop) {
8559                 rte_pktmbuf_free(ut_params->obuf);
8560                 ut_params->obuf = NULL;
8561         }
8562
8563         return ret;
8564 }
8565
8566 int
8567 test_pdcp_proto_cplane_encap(int i)
8568 {
8569         return test_pdcp_proto(
8570                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8571                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8572                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8573                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8574                 pdcp_test_params[i].cipher_key_len,
8575                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8576                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8577                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8578                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8579                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8580 }
8581
8582 int
8583 test_pdcp_proto_uplane_encap(int i)
8584 {
8585         return test_pdcp_proto(
8586                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8587                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8588                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8589                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8590                 pdcp_test_params[i].cipher_key_len,
8591                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8592                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8593                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8594                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8595                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8596 }
8597
8598 int
8599 test_pdcp_proto_uplane_encap_with_int(int i)
8600 {
8601         return test_pdcp_proto(
8602                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8603                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8604                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8605                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8606                 pdcp_test_params[i].cipher_key_len,
8607                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8608                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8609                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8610                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8611                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8612 }
8613
8614 int
8615 test_pdcp_proto_cplane_decap(int i)
8616 {
8617         return test_pdcp_proto(
8618                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8619                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8620                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8621                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8622                 pdcp_test_params[i].cipher_key_len,
8623                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8624                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8625                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8626                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8627                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8628 }
8629
8630 int
8631 test_pdcp_proto_uplane_decap(int i)
8632 {
8633         return test_pdcp_proto(
8634                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8635                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8636                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8637                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8638                 pdcp_test_params[i].cipher_key_len,
8639                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8640                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8641                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8642                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8643                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8644 }
8645
8646 int
8647 test_pdcp_proto_uplane_decap_with_int(int i)
8648 {
8649         return test_pdcp_proto(
8650                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8651                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8652                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8653                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8654                 pdcp_test_params[i].cipher_key_len,
8655                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8656                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8657                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8658                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8659                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8660 }
8661
8662 static int
8663 test_PDCP_PROTO_SGL_in_place_32B(void)
8664 {
8665         /* i can be used for running any PDCP case
8666          * In this case it is uplane 12-bit AES-SNOW DL encap
8667          */
8668         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8669         return test_pdcp_proto_SGL(i, IN_PLACE,
8670                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8671                         RTE_CRYPTO_AUTH_OP_GENERATE,
8672                         pdcp_test_data_in[i],
8673                         pdcp_test_data_in_len[i],
8674                         pdcp_test_data_out[i],
8675                         pdcp_test_data_in_len[i]+4,
8676                         32, 0);
8677 }
8678 static int
8679 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8680 {
8681         /* i can be used for running any PDCP case
8682          * In this case it is uplane 18-bit NULL-NULL DL encap
8683          */
8684         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8685         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8686                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8687                         RTE_CRYPTO_AUTH_OP_GENERATE,
8688                         pdcp_test_data_in[i],
8689                         pdcp_test_data_in_len[i],
8690                         pdcp_test_data_out[i],
8691                         pdcp_test_data_in_len[i]+4,
8692                         32, 128);
8693 }
8694 static int
8695 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8696 {
8697         /* i can be used for running any PDCP case
8698          * In this case it is uplane 18-bit AES DL encap
8699          */
8700         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8701                         + DOWNLINK;
8702         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8703                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8704                         RTE_CRYPTO_AUTH_OP_GENERATE,
8705                         pdcp_test_data_in[i],
8706                         pdcp_test_data_in_len[i],
8707                         pdcp_test_data_out[i],
8708                         pdcp_test_data_in_len[i],
8709                         32, 40);
8710 }
8711 static int
8712 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8713 {
8714         /* i can be used for running any PDCP case
8715          * In this case it is cplane 12-bit AES-ZUC DL encap
8716          */
8717         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8718         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8719                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8720                         RTE_CRYPTO_AUTH_OP_GENERATE,
8721                         pdcp_test_data_in[i],
8722                         pdcp_test_data_in_len[i],
8723                         pdcp_test_data_out[i],
8724                         pdcp_test_data_in_len[i]+4,
8725                         128, 32);
8726 }
8727
8728 static int
8729 test_PDCP_SDAP_PROTO_encap_all(void)
8730 {
8731         int i = 0, size = 0;
8732         int err, all_err = TEST_SUCCESS;
8733         const struct pdcp_sdap_test *cur_test;
8734
8735         size = RTE_DIM(list_pdcp_sdap_tests);
8736
8737         for (i = 0; i < size; i++) {
8738                 cur_test = &list_pdcp_sdap_tests[i];
8739                 err = test_pdcp_proto(
8740                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8741                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8742                         cur_test->in_len, cur_test->data_out,
8743                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8744                         cur_test->param.cipher_alg, cur_test->cipher_key,
8745                         cur_test->param.cipher_key_len,
8746                         cur_test->param.auth_alg,
8747                         cur_test->auth_key, cur_test->param.auth_key_len,
8748                         cur_test->bearer, cur_test->param.domain,
8749                         cur_test->packet_direction, cur_test->sn_size,
8750                         cur_test->hfn,
8751                         cur_test->hfn_threshold, SDAP_ENABLED);
8752                 if (err) {
8753                         printf("\t%d) %s: Encapsulation failed\n",
8754                                         cur_test->test_idx,
8755                                         cur_test->param.name);
8756                         err = TEST_FAILED;
8757                 } else {
8758                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8759                                         cur_test->param.name);
8760                         err = TEST_SUCCESS;
8761                 }
8762                 all_err += err;
8763         }
8764
8765         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8766
8767         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8768 }
8769
8770 static int
8771 test_PDCP_SDAP_PROTO_decap_all(void)
8772 {
8773         int i = 0, size = 0;
8774         int err, all_err = TEST_SUCCESS;
8775         const struct pdcp_sdap_test *cur_test;
8776
8777         size = RTE_DIM(list_pdcp_sdap_tests);
8778
8779         for (i = 0; i < size; i++) {
8780                 cur_test = &list_pdcp_sdap_tests[i];
8781                 err = test_pdcp_proto(
8782                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8783                         RTE_CRYPTO_AUTH_OP_VERIFY,
8784                         cur_test->data_out,
8785                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8786                         cur_test->data_in, cur_test->in_len,
8787                         cur_test->param.cipher_alg,
8788                         cur_test->cipher_key, cur_test->param.cipher_key_len,
8789                         cur_test->param.auth_alg, cur_test->auth_key,
8790                         cur_test->param.auth_key_len, cur_test->bearer,
8791                         cur_test->param.domain, cur_test->packet_direction,
8792                         cur_test->sn_size, cur_test->hfn,
8793                         cur_test->hfn_threshold, SDAP_ENABLED);
8794                 if (err) {
8795                         printf("\t%d) %s: Decapsulation failed\n",
8796                                         cur_test->test_idx,
8797                                         cur_test->param.name);
8798                         err = TEST_FAILED;
8799                 } else {
8800                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8801                                         cur_test->param.name);
8802                         err = TEST_SUCCESS;
8803                 }
8804                 all_err += err;
8805         }
8806
8807         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8808
8809         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8810 }
8811
8812 static int
8813 test_PDCP_PROTO_all(void)
8814 {
8815         struct crypto_testsuite_params *ts_params = &testsuite_params;
8816         struct crypto_unittest_params *ut_params = &unittest_params;
8817         struct rte_cryptodev_info dev_info;
8818         int status;
8819
8820         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8821         uint64_t feat_flags = dev_info.feature_flags;
8822
8823         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8824                 return TEST_SKIPPED;
8825
8826         /* Set action type */
8827         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8828                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8829                 gbl_action_type;
8830
8831         if (security_proto_supported(ut_params->type,
8832                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
8833                 return TEST_SKIPPED;
8834
8835         status = test_PDCP_PROTO_cplane_encap_all();
8836         status += test_PDCP_PROTO_cplane_decap_all();
8837         status += test_PDCP_PROTO_uplane_encap_all();
8838         status += test_PDCP_PROTO_uplane_decap_all();
8839         status += test_PDCP_PROTO_SGL_in_place_32B();
8840         status += test_PDCP_PROTO_SGL_oop_32B_128B();
8841         status += test_PDCP_PROTO_SGL_oop_32B_40B();
8842         status += test_PDCP_PROTO_SGL_oop_128B_32B();
8843         status += test_PDCP_SDAP_PROTO_encap_all();
8844         status += test_PDCP_SDAP_PROTO_decap_all();
8845
8846         if (status)
8847                 return TEST_FAILED;
8848         else
8849                 return TEST_SUCCESS;
8850 }
8851
8852 static int
8853 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
8854 {
8855         struct crypto_testsuite_params *ts_params = &testsuite_params;
8856         struct crypto_unittest_params *ut_params = &unittest_params;
8857         uint8_t *plaintext, *ciphertext;
8858         uint8_t *iv_ptr;
8859         int32_t cipher_len, crc_len;
8860         uint32_t crc_data_len;
8861         int ret = TEST_SUCCESS;
8862
8863         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8864                                         rte_cryptodev_get_sec_ctx(
8865                                                 ts_params->valid_devs[0]);
8866
8867         /* Verify the capabilities */
8868         struct rte_security_capability_idx sec_cap_idx;
8869         const struct rte_security_capability *sec_cap;
8870         const struct rte_cryptodev_capabilities *crypto_cap;
8871         const struct rte_cryptodev_symmetric_capability *sym_cap;
8872         int j = 0;
8873
8874         sec_cap_idx.action = ut_params->type;
8875         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8876         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
8877
8878         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8879         if (sec_cap == NULL)
8880                 return TEST_SKIPPED;
8881
8882         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8883                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8884                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8885                                 crypto_cap->sym.xform_type ==
8886                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8887                                 crypto_cap->sym.cipher.algo ==
8888                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8889                         sym_cap = &crypto_cap->sym;
8890                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8891                                                 d_td->key.len,
8892                                                 d_td->iv.len) == 0)
8893                                 break;
8894                 }
8895         }
8896
8897         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8898                 return TEST_SKIPPED;
8899
8900         /* Setup source mbuf payload */
8901         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8902         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8903                         rte_pktmbuf_tailroom(ut_params->ibuf));
8904
8905         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8906                         d_td->ciphertext.len);
8907
8908         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
8909
8910         /* Setup cipher session parameters */
8911         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8912         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8913         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
8914         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8915         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8916         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8917         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8918         ut_params->cipher_xform.next = NULL;
8919
8920         /* Setup DOCSIS session parameters */
8921         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
8922
8923         struct rte_security_session_conf sess_conf = {
8924                 .action_type = ut_params->type,
8925                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8926                 .docsis = ut_params->docsis_xform,
8927                 .crypto_xform = &ut_params->cipher_xform,
8928         };
8929
8930         /* Create security session */
8931         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8932                                         ts_params->session_mpool,
8933                                         ts_params->session_priv_mpool);
8934
8935         if (!ut_params->sec_session) {
8936                 printf("TestCase %s(%d) line %d: %s\n",
8937                         __func__, i, __LINE__, "failed to allocate session");
8938                 ret = TEST_FAILED;
8939                 goto on_err;
8940         }
8941
8942         /* Generate crypto op data structure */
8943         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8944                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8945         if (!ut_params->op) {
8946                 printf("TestCase %s(%d) line %d: %s\n",
8947                         __func__, i, __LINE__,
8948                         "failed to allocate symmetric crypto operation");
8949                 ret = TEST_FAILED;
8950                 goto on_err;
8951         }
8952
8953         /* Setup CRC operation parameters */
8954         crc_len = d_td->ciphertext.no_crc == false ?
8955                         (d_td->ciphertext.len -
8956                                 d_td->ciphertext.crc_offset -
8957                                 RTE_ETHER_CRC_LEN) :
8958                         0;
8959         crc_len = crc_len > 0 ? crc_len : 0;
8960         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
8961         ut_params->op->sym->auth.data.length = crc_len;
8962         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
8963
8964         /* Setup cipher operation parameters */
8965         cipher_len = d_td->ciphertext.no_cipher == false ?
8966                         (d_td->ciphertext.len -
8967                                 d_td->ciphertext.cipher_offset) :
8968                         0;
8969         cipher_len = cipher_len > 0 ? cipher_len : 0;
8970         ut_params->op->sym->cipher.data.length = cipher_len;
8971         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
8972
8973         /* Setup cipher IV */
8974         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8975         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8976
8977         /* Attach session to operation */
8978         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8979
8980         /* Set crypto operation mbufs */
8981         ut_params->op->sym->m_src = ut_params->ibuf;
8982         ut_params->op->sym->m_dst = NULL;
8983
8984         /* Process crypto operation */
8985         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8986                         NULL) {
8987                 printf("TestCase %s(%d) line %d: %s\n",
8988                         __func__, i, __LINE__,
8989                         "failed to process security crypto op");
8990                 ret = TEST_FAILED;
8991                 goto on_err;
8992         }
8993
8994         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8995                 printf("TestCase %s(%d) line %d: %s\n",
8996                         __func__, i, __LINE__, "crypto op processing failed");
8997                 ret = TEST_FAILED;
8998                 goto on_err;
8999         }
9000
9001         /* Validate plaintext */
9002         plaintext = ciphertext;
9003
9004         if (memcmp(plaintext, d_td->plaintext.data,
9005                         d_td->plaintext.len - crc_data_len)) {
9006                 printf("TestCase %s(%d) line %d: %s\n",
9007                         __func__, i, __LINE__, "plaintext not as expected\n");
9008                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9009                                 d_td->plaintext.len);
9010                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9011                 ret = TEST_FAILED;
9012                 goto on_err;
9013         }
9014
9015 on_err:
9016         rte_crypto_op_free(ut_params->op);
9017         ut_params->op = NULL;
9018
9019         if (ut_params->sec_session)
9020                 rte_security_session_destroy(ctx, ut_params->sec_session);
9021         ut_params->sec_session = NULL;
9022
9023         rte_pktmbuf_free(ut_params->ibuf);
9024         ut_params->ibuf = NULL;
9025
9026         return ret;
9027 }
9028
9029 static int
9030 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
9031 {
9032         struct crypto_testsuite_params *ts_params = &testsuite_params;
9033         struct crypto_unittest_params *ut_params = &unittest_params;
9034         uint8_t *plaintext, *ciphertext;
9035         uint8_t *iv_ptr;
9036         int32_t cipher_len, crc_len;
9037         int ret = TEST_SUCCESS;
9038
9039         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9040                                         rte_cryptodev_get_sec_ctx(
9041                                                 ts_params->valid_devs[0]);
9042
9043         /* Verify the capabilities */
9044         struct rte_security_capability_idx sec_cap_idx;
9045         const struct rte_security_capability *sec_cap;
9046         const struct rte_cryptodev_capabilities *crypto_cap;
9047         const struct rte_cryptodev_symmetric_capability *sym_cap;
9048         int j = 0;
9049
9050         sec_cap_idx.action = ut_params->type;
9051         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9052         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9053
9054         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9055         if (sec_cap == NULL)
9056                 return TEST_SKIPPED;
9057
9058         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9059                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9060                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9061                                 crypto_cap->sym.xform_type ==
9062                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9063                                 crypto_cap->sym.cipher.algo ==
9064                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9065                         sym_cap = &crypto_cap->sym;
9066                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9067                                                 d_td->key.len,
9068                                                 d_td->iv.len) == 0)
9069                                 break;
9070                 }
9071         }
9072
9073         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9074                 return TEST_SKIPPED;
9075
9076         /* Setup source mbuf payload */
9077         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9078         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9079                         rte_pktmbuf_tailroom(ut_params->ibuf));
9080
9081         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9082                         d_td->plaintext.len);
9083
9084         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9085
9086         /* Setup cipher session parameters */
9087         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9088         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9089         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9090         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9091         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9092         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9093         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9094         ut_params->cipher_xform.next = NULL;
9095
9096         /* Setup DOCSIS session parameters */
9097         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9098
9099         struct rte_security_session_conf sess_conf = {
9100                 .action_type = ut_params->type,
9101                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9102                 .docsis = ut_params->docsis_xform,
9103                 .crypto_xform = &ut_params->cipher_xform,
9104         };
9105
9106         /* Create security session */
9107         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9108                                         ts_params->session_mpool,
9109                                         ts_params->session_priv_mpool);
9110
9111         if (!ut_params->sec_session) {
9112                 printf("TestCase %s(%d) line %d: %s\n",
9113                         __func__, i, __LINE__, "failed to allocate session");
9114                 ret = TEST_FAILED;
9115                 goto on_err;
9116         }
9117
9118         /* Generate crypto op data structure */
9119         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9120                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9121         if (!ut_params->op) {
9122                 printf("TestCase %s(%d) line %d: %s\n",
9123                         __func__, i, __LINE__,
9124                         "failed to allocate security crypto operation");
9125                 ret = TEST_FAILED;
9126                 goto on_err;
9127         }
9128
9129         /* Setup CRC operation parameters */
9130         crc_len = d_td->plaintext.no_crc == false ?
9131                         (d_td->plaintext.len -
9132                                 d_td->plaintext.crc_offset -
9133                                 RTE_ETHER_CRC_LEN) :
9134                         0;
9135         crc_len = crc_len > 0 ? crc_len : 0;
9136         ut_params->op->sym->auth.data.length = crc_len;
9137         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
9138
9139         /* Setup cipher operation parameters */
9140         cipher_len = d_td->plaintext.no_cipher == false ?
9141                         (d_td->plaintext.len -
9142                                 d_td->plaintext.cipher_offset) :
9143                         0;
9144         cipher_len = cipher_len > 0 ? cipher_len : 0;
9145         ut_params->op->sym->cipher.data.length = cipher_len;
9146         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
9147
9148         /* Setup cipher IV */
9149         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9150         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9151
9152         /* Attach session to operation */
9153         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9154
9155         /* Set crypto operation mbufs */
9156         ut_params->op->sym->m_src = ut_params->ibuf;
9157         ut_params->op->sym->m_dst = NULL;
9158
9159         /* Process crypto operation */
9160         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9161                         NULL) {
9162                 printf("TestCase %s(%d) line %d: %s\n",
9163                         __func__, i, __LINE__,
9164                         "failed to process security crypto op");
9165                 ret = TEST_FAILED;
9166                 goto on_err;
9167         }
9168
9169         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9170                 printf("TestCase %s(%d) line %d: %s\n",
9171                         __func__, i, __LINE__, "crypto op processing failed");
9172                 ret = TEST_FAILED;
9173                 goto on_err;
9174         }
9175
9176         /* Validate ciphertext */
9177         ciphertext = plaintext;
9178
9179         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
9180                 printf("TestCase %s(%d) line %d: %s\n",
9181                         __func__, i, __LINE__, "ciphertext not as expected\n");
9182                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
9183                                 d_td->ciphertext.len);
9184                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
9185                 ret = TEST_FAILED;
9186                 goto on_err;
9187         }
9188
9189 on_err:
9190         rte_crypto_op_free(ut_params->op);
9191         ut_params->op = NULL;
9192
9193         if (ut_params->sec_session)
9194                 rte_security_session_destroy(ctx, ut_params->sec_session);
9195         ut_params->sec_session = NULL;
9196
9197         rte_pktmbuf_free(ut_params->ibuf);
9198         ut_params->ibuf = NULL;
9199
9200         return ret;
9201 }
9202
9203 #define TEST_DOCSIS_COUNT(func) do {                    \
9204         int ret = func;                                 \
9205         if (ret == TEST_SUCCESS)  {                     \
9206                 printf("\t%2d)", n++);                  \
9207                 printf("+++++ PASSED:" #func"\n");      \
9208                 p++;                                    \
9209         } else if (ret == TEST_SKIPPED) {               \
9210                 printf("\t%2d)", n++);                  \
9211                 printf("~~~~~ SKIPPED:" #func"\n");     \
9212                 s++;                                    \
9213         } else {                                        \
9214                 printf("\t%2d)", n++);                  \
9215                 printf("----- FAILED:" #func"\n");      \
9216                 f++;                                    \
9217         }                                               \
9218 } while (0)
9219
9220 static int
9221 test_DOCSIS_PROTO_uplink_all(void)
9222 {
9223         int p = 0, s = 0, f = 0, n = 0;
9224
9225         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
9226         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
9227         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
9228         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
9229         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
9230         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
9231         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
9232         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
9233         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
9234         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
9235         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
9236         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
9237         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
9238         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
9239         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
9240         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
9241         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
9242         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
9243         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
9244         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
9245         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
9246         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
9247         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
9248         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
9249         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
9250         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
9251
9252         if (f)
9253                 printf("## %s: %d passed out of %d (%d skipped)\n",
9254                         __func__, p, n, s);
9255
9256         return f;
9257 };
9258
9259 static int
9260 test_DOCSIS_PROTO_downlink_all(void)
9261 {
9262         int p = 0, s = 0, f = 0, n = 0;
9263
9264         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
9265         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
9266         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
9267         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
9268         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
9269         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
9270         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
9271         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
9272         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
9273         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
9274         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
9275         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
9276         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
9277         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
9278         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
9279         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
9280         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
9281         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
9282         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
9283         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
9284         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
9285         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
9286         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
9287         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
9288         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
9289         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
9290
9291         if (f)
9292                 printf("## %s: %d passed out of %d (%d skipped)\n",
9293                         __func__, p, n, s);
9294
9295         return f;
9296 };
9297
9298 static int
9299 test_DOCSIS_PROTO_all(void)
9300 {
9301         struct crypto_testsuite_params *ts_params = &testsuite_params;
9302         struct crypto_unittest_params *ut_params = &unittest_params;
9303         struct rte_cryptodev_info dev_info;
9304         int status;
9305
9306         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9307         uint64_t feat_flags = dev_info.feature_flags;
9308
9309         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9310                 return TEST_SKIPPED;
9311
9312         /* Set action type */
9313         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9314                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9315                 gbl_action_type;
9316
9317         if (security_proto_supported(ut_params->type,
9318                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9319                 return TEST_SKIPPED;
9320
9321         status = test_DOCSIS_PROTO_uplink_all();
9322         status += test_DOCSIS_PROTO_downlink_all();
9323
9324         if (status)
9325                 return TEST_FAILED;
9326         else
9327                 return TEST_SUCCESS;
9328 }
9329 #endif
9330
9331 static int
9332 test_AES_GCM_authenticated_encryption_test_case_1(void)
9333 {
9334         return test_authenticated_encryption(&gcm_test_case_1);
9335 }
9336
9337 static int
9338 test_AES_GCM_authenticated_encryption_test_case_2(void)
9339 {
9340         return test_authenticated_encryption(&gcm_test_case_2);
9341 }
9342
9343 static int
9344 test_AES_GCM_authenticated_encryption_test_case_3(void)
9345 {
9346         return test_authenticated_encryption(&gcm_test_case_3);
9347 }
9348
9349 static int
9350 test_AES_GCM_authenticated_encryption_test_case_4(void)
9351 {
9352         return test_authenticated_encryption(&gcm_test_case_4);
9353 }
9354
9355 static int
9356 test_AES_GCM_authenticated_encryption_test_case_5(void)
9357 {
9358         return test_authenticated_encryption(&gcm_test_case_5);
9359 }
9360
9361 static int
9362 test_AES_GCM_authenticated_encryption_test_case_6(void)
9363 {
9364         return test_authenticated_encryption(&gcm_test_case_6);
9365 }
9366
9367 static int
9368 test_AES_GCM_authenticated_encryption_test_case_7(void)
9369 {
9370         return test_authenticated_encryption(&gcm_test_case_7);
9371 }
9372
9373 static int
9374 test_AES_GCM_authenticated_encryption_test_case_8(void)
9375 {
9376         return test_authenticated_encryption(&gcm_test_case_8);
9377 }
9378
9379 static int
9380 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9381 {
9382         return test_authenticated_encryption(&gcm_J0_test_case_1);
9383 }
9384
9385 static int
9386 test_AES_GCM_auth_encryption_test_case_192_1(void)
9387 {
9388         return test_authenticated_encryption(&gcm_test_case_192_1);
9389 }
9390
9391 static int
9392 test_AES_GCM_auth_encryption_test_case_192_2(void)
9393 {
9394         return test_authenticated_encryption(&gcm_test_case_192_2);
9395 }
9396
9397 static int
9398 test_AES_GCM_auth_encryption_test_case_192_3(void)
9399 {
9400         return test_authenticated_encryption(&gcm_test_case_192_3);
9401 }
9402
9403 static int
9404 test_AES_GCM_auth_encryption_test_case_192_4(void)
9405 {
9406         return test_authenticated_encryption(&gcm_test_case_192_4);
9407 }
9408
9409 static int
9410 test_AES_GCM_auth_encryption_test_case_192_5(void)
9411 {
9412         return test_authenticated_encryption(&gcm_test_case_192_5);
9413 }
9414
9415 static int
9416 test_AES_GCM_auth_encryption_test_case_192_6(void)
9417 {
9418         return test_authenticated_encryption(&gcm_test_case_192_6);
9419 }
9420
9421 static int
9422 test_AES_GCM_auth_encryption_test_case_192_7(void)
9423 {
9424         return test_authenticated_encryption(&gcm_test_case_192_7);
9425 }
9426
9427 static int
9428 test_AES_GCM_auth_encryption_test_case_256_1(void)
9429 {
9430         return test_authenticated_encryption(&gcm_test_case_256_1);
9431 }
9432
9433 static int
9434 test_AES_GCM_auth_encryption_test_case_256_2(void)
9435 {
9436         return test_authenticated_encryption(&gcm_test_case_256_2);
9437 }
9438
9439 static int
9440 test_AES_GCM_auth_encryption_test_case_256_3(void)
9441 {
9442         return test_authenticated_encryption(&gcm_test_case_256_3);
9443 }
9444
9445 static int
9446 test_AES_GCM_auth_encryption_test_case_256_4(void)
9447 {
9448         return test_authenticated_encryption(&gcm_test_case_256_4);
9449 }
9450
9451 static int
9452 test_AES_GCM_auth_encryption_test_case_256_5(void)
9453 {
9454         return test_authenticated_encryption(&gcm_test_case_256_5);
9455 }
9456
9457 static int
9458 test_AES_GCM_auth_encryption_test_case_256_6(void)
9459 {
9460         return test_authenticated_encryption(&gcm_test_case_256_6);
9461 }
9462
9463 static int
9464 test_AES_GCM_auth_encryption_test_case_256_7(void)
9465 {
9466         return test_authenticated_encryption(&gcm_test_case_256_7);
9467 }
9468
9469 static int
9470 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9471 {
9472         return test_authenticated_encryption(&gcm_test_case_aad_1);
9473 }
9474
9475 static int
9476 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9477 {
9478         return test_authenticated_encryption(&gcm_test_case_aad_2);
9479 }
9480
9481 static int
9482 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9483 {
9484         struct aead_test_data tdata;
9485         int res;
9486
9487         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9488         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9489         tdata.iv.data[0] += 1;
9490         res = test_authenticated_encryption(&tdata);
9491         if (res == TEST_SKIPPED)
9492                 return res;
9493         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9494         return TEST_SUCCESS;
9495 }
9496
9497 static int
9498 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9499 {
9500         struct aead_test_data tdata;
9501         int res;
9502
9503         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9504         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9505         tdata.plaintext.data[0] += 1;
9506         res = test_authenticated_encryption(&tdata);
9507         if (res == TEST_SKIPPED)
9508                 return res;
9509         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9510         return TEST_SUCCESS;
9511 }
9512
9513 static int
9514 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9515 {
9516         struct aead_test_data tdata;
9517         int res;
9518
9519         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9520         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9521         tdata.ciphertext.data[0] += 1;
9522         res = test_authenticated_encryption(&tdata);
9523         if (res == TEST_SKIPPED)
9524                 return res;
9525         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9526         return TEST_SUCCESS;
9527 }
9528
9529 static int
9530 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9531 {
9532         struct aead_test_data tdata;
9533         int res;
9534
9535         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9536         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9537         tdata.aad.len += 1;
9538         res = test_authenticated_encryption(&tdata);
9539         if (res == TEST_SKIPPED)
9540                 return res;
9541         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9542         return TEST_SUCCESS;
9543 }
9544
9545 static int
9546 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9547 {
9548         struct aead_test_data tdata;
9549         uint8_t aad[gcm_test_case_7.aad.len];
9550         int res;
9551
9552         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9553         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9554         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9555         aad[0] += 1;
9556         tdata.aad.data = aad;
9557         res = test_authenticated_encryption(&tdata);
9558         if (res == TEST_SKIPPED)
9559                 return res;
9560         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9561         return TEST_SUCCESS;
9562 }
9563
9564 static int
9565 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9566 {
9567         struct aead_test_data tdata;
9568         int res;
9569
9570         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9571         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9572         tdata.auth_tag.data[0] += 1;
9573         res = test_authenticated_encryption(&tdata);
9574         if (res == TEST_SKIPPED)
9575                 return res;
9576         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9577         return TEST_SUCCESS;
9578 }
9579
9580 static int
9581 test_authenticated_decryption(const struct aead_test_data *tdata)
9582 {
9583         struct crypto_testsuite_params *ts_params = &testsuite_params;
9584         struct crypto_unittest_params *ut_params = &unittest_params;
9585
9586         int retval;
9587         uint8_t *plaintext;
9588         uint32_t i;
9589         struct rte_cryptodev_info dev_info;
9590
9591         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9592         uint64_t feat_flags = dev_info.feature_flags;
9593
9594         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9595                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9596                 printf("Device doesn't support RAW data-path APIs.\n");
9597                 return TEST_SKIPPED;
9598         }
9599
9600         /* Verify the capabilities */
9601         struct rte_cryptodev_sym_capability_idx cap_idx;
9602         const struct rte_cryptodev_symmetric_capability *capability;
9603         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9604         cap_idx.algo.aead = tdata->algo;
9605         capability = rte_cryptodev_sym_capability_get(
9606                         ts_params->valid_devs[0], &cap_idx);
9607         if (capability == NULL)
9608                 return TEST_SKIPPED;
9609         if (rte_cryptodev_sym_capability_check_aead(
9610                         capability, tdata->key.len, tdata->auth_tag.len,
9611                         tdata->aad.len, tdata->iv.len))
9612                 return TEST_SKIPPED;
9613
9614         /* Create AEAD session */
9615         retval = create_aead_session(ts_params->valid_devs[0],
9616                         tdata->algo,
9617                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9618                         tdata->key.data, tdata->key.len,
9619                         tdata->aad.len, tdata->auth_tag.len,
9620                         tdata->iv.len);
9621         if (retval < 0)
9622                 return retval;
9623
9624         /* alloc mbuf and set payload */
9625         if (tdata->aad.len > MBUF_SIZE) {
9626                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9627                 /* Populate full size of add data */
9628                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9629                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9630         } else
9631                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9632
9633         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9634                         rte_pktmbuf_tailroom(ut_params->ibuf));
9635
9636         /* Create AEAD operation */
9637         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9638         if (retval < 0)
9639                 return retval;
9640
9641         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9642
9643         ut_params->op->sym->m_src = ut_params->ibuf;
9644
9645         /* Process crypto operation */
9646         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9647                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9648         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9649                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9650                                 ut_params->op, 0, 0, 0, 0);
9651         else
9652                 TEST_ASSERT_NOT_NULL(
9653                         process_crypto_request(ts_params->valid_devs[0],
9654                         ut_params->op), "failed to process sym crypto op");
9655
9656         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9657                         "crypto op processing failed");
9658
9659         if (ut_params->op->sym->m_dst)
9660                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
9661                                 uint8_t *);
9662         else
9663                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
9664                                 uint8_t *,
9665                                 ut_params->op->sym->cipher.data.offset);
9666
9667         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9668
9669         /* Validate obuf */
9670         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9671                         plaintext,
9672                         tdata->plaintext.data,
9673                         tdata->plaintext.len,
9674                         "Plaintext data not as expected");
9675
9676         TEST_ASSERT_EQUAL(ut_params->op->status,
9677                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9678                         "Authentication failed");
9679
9680         return 0;
9681 }
9682
9683 static int
9684 test_AES_GCM_authenticated_decryption_test_case_1(void)
9685 {
9686         return test_authenticated_decryption(&gcm_test_case_1);
9687 }
9688
9689 static int
9690 test_AES_GCM_authenticated_decryption_test_case_2(void)
9691 {
9692         return test_authenticated_decryption(&gcm_test_case_2);
9693 }
9694
9695 static int
9696 test_AES_GCM_authenticated_decryption_test_case_3(void)
9697 {
9698         return test_authenticated_decryption(&gcm_test_case_3);
9699 }
9700
9701 static int
9702 test_AES_GCM_authenticated_decryption_test_case_4(void)
9703 {
9704         return test_authenticated_decryption(&gcm_test_case_4);
9705 }
9706
9707 static int
9708 test_AES_GCM_authenticated_decryption_test_case_5(void)
9709 {
9710         return test_authenticated_decryption(&gcm_test_case_5);
9711 }
9712
9713 static int
9714 test_AES_GCM_authenticated_decryption_test_case_6(void)
9715 {
9716         return test_authenticated_decryption(&gcm_test_case_6);
9717 }
9718
9719 static int
9720 test_AES_GCM_authenticated_decryption_test_case_7(void)
9721 {
9722         return test_authenticated_decryption(&gcm_test_case_7);
9723 }
9724
9725 static int
9726 test_AES_GCM_authenticated_decryption_test_case_8(void)
9727 {
9728         return test_authenticated_decryption(&gcm_test_case_8);
9729 }
9730
9731 static int
9732 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
9733 {
9734         return test_authenticated_decryption(&gcm_J0_test_case_1);
9735 }
9736
9737 static int
9738 test_AES_GCM_auth_decryption_test_case_192_1(void)
9739 {
9740         return test_authenticated_decryption(&gcm_test_case_192_1);
9741 }
9742
9743 static int
9744 test_AES_GCM_auth_decryption_test_case_192_2(void)
9745 {
9746         return test_authenticated_decryption(&gcm_test_case_192_2);
9747 }
9748
9749 static int
9750 test_AES_GCM_auth_decryption_test_case_192_3(void)
9751 {
9752         return test_authenticated_decryption(&gcm_test_case_192_3);
9753 }
9754
9755 static int
9756 test_AES_GCM_auth_decryption_test_case_192_4(void)
9757 {
9758         return test_authenticated_decryption(&gcm_test_case_192_4);
9759 }
9760
9761 static int
9762 test_AES_GCM_auth_decryption_test_case_192_5(void)
9763 {
9764         return test_authenticated_decryption(&gcm_test_case_192_5);
9765 }
9766
9767 static int
9768 test_AES_GCM_auth_decryption_test_case_192_6(void)
9769 {
9770         return test_authenticated_decryption(&gcm_test_case_192_6);
9771 }
9772
9773 static int
9774 test_AES_GCM_auth_decryption_test_case_192_7(void)
9775 {
9776         return test_authenticated_decryption(&gcm_test_case_192_7);
9777 }
9778
9779 static int
9780 test_AES_GCM_auth_decryption_test_case_256_1(void)
9781 {
9782         return test_authenticated_decryption(&gcm_test_case_256_1);
9783 }
9784
9785 static int
9786 test_AES_GCM_auth_decryption_test_case_256_2(void)
9787 {
9788         return test_authenticated_decryption(&gcm_test_case_256_2);
9789 }
9790
9791 static int
9792 test_AES_GCM_auth_decryption_test_case_256_3(void)
9793 {
9794         return test_authenticated_decryption(&gcm_test_case_256_3);
9795 }
9796
9797 static int
9798 test_AES_GCM_auth_decryption_test_case_256_4(void)
9799 {
9800         return test_authenticated_decryption(&gcm_test_case_256_4);
9801 }
9802
9803 static int
9804 test_AES_GCM_auth_decryption_test_case_256_5(void)
9805 {
9806         return test_authenticated_decryption(&gcm_test_case_256_5);
9807 }
9808
9809 static int
9810 test_AES_GCM_auth_decryption_test_case_256_6(void)
9811 {
9812         return test_authenticated_decryption(&gcm_test_case_256_6);
9813 }
9814
9815 static int
9816 test_AES_GCM_auth_decryption_test_case_256_7(void)
9817 {
9818         return test_authenticated_decryption(&gcm_test_case_256_7);
9819 }
9820
9821 static int
9822 test_AES_GCM_auth_decryption_test_case_aad_1(void)
9823 {
9824         return test_authenticated_decryption(&gcm_test_case_aad_1);
9825 }
9826
9827 static int
9828 test_AES_GCM_auth_decryption_test_case_aad_2(void)
9829 {
9830         return test_authenticated_decryption(&gcm_test_case_aad_2);
9831 }
9832
9833 static int
9834 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
9835 {
9836         struct aead_test_data tdata;
9837         int res;
9838
9839         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9840         tdata.iv.data[0] += 1;
9841         res = test_authenticated_decryption(&tdata);
9842         if (res == TEST_SKIPPED)
9843                 return res;
9844         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9845         return TEST_SUCCESS;
9846 }
9847
9848 static int
9849 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
9850 {
9851         struct aead_test_data tdata;
9852         int res;
9853
9854         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9855         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9856         tdata.plaintext.data[0] += 1;
9857         res = test_authenticated_decryption(&tdata);
9858         if (res == TEST_SKIPPED)
9859                 return res;
9860         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9861         return TEST_SUCCESS;
9862 }
9863
9864 static int
9865 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
9866 {
9867         struct aead_test_data tdata;
9868         int res;
9869
9870         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9871         tdata.ciphertext.data[0] += 1;
9872         res = test_authenticated_decryption(&tdata);
9873         if (res == TEST_SKIPPED)
9874                 return res;
9875         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9876         return TEST_SUCCESS;
9877 }
9878
9879 static int
9880 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
9881 {
9882         struct aead_test_data tdata;
9883         int res;
9884
9885         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9886         tdata.aad.len += 1;
9887         res = test_authenticated_decryption(&tdata);
9888         if (res == TEST_SKIPPED)
9889                 return res;
9890         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9891         return TEST_SUCCESS;
9892 }
9893
9894 static int
9895 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9896 {
9897         struct aead_test_data tdata;
9898         uint8_t aad[gcm_test_case_7.aad.len];
9899         int res;
9900
9901         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9902         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9903         aad[0] += 1;
9904         tdata.aad.data = aad;
9905         res = test_authenticated_decryption(&tdata);
9906         if (res == TEST_SKIPPED)
9907                 return res;
9908         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9909         return TEST_SUCCESS;
9910 }
9911
9912 static int
9913 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9914 {
9915         struct aead_test_data tdata;
9916         int res;
9917
9918         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9919         tdata.auth_tag.data[0] += 1;
9920         res = test_authenticated_decryption(&tdata);
9921         if (res == TEST_SKIPPED)
9922                 return res;
9923         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9924         return TEST_SUCCESS;
9925 }
9926
9927 static int
9928 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9929 {
9930         struct crypto_testsuite_params *ts_params = &testsuite_params;
9931         struct crypto_unittest_params *ut_params = &unittest_params;
9932
9933         int retval;
9934         uint8_t *ciphertext, *auth_tag;
9935         uint16_t plaintext_pad_len;
9936
9937         /* Verify the capabilities */
9938         struct rte_cryptodev_sym_capability_idx cap_idx;
9939         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9940         cap_idx.algo.aead = tdata->algo;
9941         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9942                         &cap_idx) == NULL)
9943                 return TEST_SKIPPED;
9944
9945         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9946                 return TEST_SKIPPED;
9947
9948         /* not supported with CPU crypto */
9949         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9950                 return TEST_SKIPPED;
9951
9952         /* Create AEAD session */
9953         retval = create_aead_session(ts_params->valid_devs[0],
9954                         tdata->algo,
9955                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9956                         tdata->key.data, tdata->key.len,
9957                         tdata->aad.len, tdata->auth_tag.len,
9958                         tdata->iv.len);
9959         if (retval < 0)
9960                 return retval;
9961
9962         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9963         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9964
9965         /* clear mbuf payload */
9966         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9967                         rte_pktmbuf_tailroom(ut_params->ibuf));
9968         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9969                         rte_pktmbuf_tailroom(ut_params->obuf));
9970
9971         /* Create AEAD operation */
9972         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9973         if (retval < 0)
9974                 return retval;
9975
9976         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9977
9978         ut_params->op->sym->m_src = ut_params->ibuf;
9979         ut_params->op->sym->m_dst = ut_params->obuf;
9980
9981         /* Process crypto operation */
9982         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9983                         ut_params->op), "failed to process sym crypto op");
9984
9985         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9986                         "crypto op processing failed");
9987
9988         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9989
9990         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9991                         ut_params->op->sym->cipher.data.offset);
9992         auth_tag = ciphertext + plaintext_pad_len;
9993
9994         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9995         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9996
9997         /* Validate obuf */
9998         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9999                         ciphertext,
10000                         tdata->ciphertext.data,
10001                         tdata->ciphertext.len,
10002                         "Ciphertext data not as expected");
10003
10004         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10005                         auth_tag,
10006                         tdata->auth_tag.data,
10007                         tdata->auth_tag.len,
10008                         "Generated auth tag not as expected");
10009
10010         return 0;
10011
10012 }
10013
10014 static int
10015 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10016 {
10017         return test_authenticated_encryption_oop(&gcm_test_case_5);
10018 }
10019
10020 static int
10021 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10022 {
10023         struct crypto_testsuite_params *ts_params = &testsuite_params;
10024         struct crypto_unittest_params *ut_params = &unittest_params;
10025
10026         int retval;
10027         uint8_t *plaintext;
10028
10029         /* Verify the capabilities */
10030         struct rte_cryptodev_sym_capability_idx cap_idx;
10031         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10032         cap_idx.algo.aead = tdata->algo;
10033         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10034                         &cap_idx) == NULL)
10035                 return TEST_SKIPPED;
10036
10037         /* not supported with CPU crypto and raw data-path APIs*/
10038         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10039                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10040                 return TEST_SKIPPED;
10041
10042         /* Create AEAD session */
10043         retval = create_aead_session(ts_params->valid_devs[0],
10044                         tdata->algo,
10045                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10046                         tdata->key.data, tdata->key.len,
10047                         tdata->aad.len, tdata->auth_tag.len,
10048                         tdata->iv.len);
10049         if (retval < 0)
10050                 return retval;
10051
10052         /* alloc mbuf and set payload */
10053         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10054         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10055
10056         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10057                         rte_pktmbuf_tailroom(ut_params->ibuf));
10058         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10059                         rte_pktmbuf_tailroom(ut_params->obuf));
10060
10061         /* Create AEAD operation */
10062         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10063         if (retval < 0)
10064                 return retval;
10065
10066         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10067
10068         ut_params->op->sym->m_src = ut_params->ibuf;
10069         ut_params->op->sym->m_dst = ut_params->obuf;
10070
10071         /* Process crypto operation */
10072         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10073                         ut_params->op), "failed to process sym crypto op");
10074
10075         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10076                         "crypto op processing failed");
10077
10078         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10079                         ut_params->op->sym->cipher.data.offset);
10080
10081         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10082
10083         /* Validate obuf */
10084         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10085                         plaintext,
10086                         tdata->plaintext.data,
10087                         tdata->plaintext.len,
10088                         "Plaintext data not as expected");
10089
10090         TEST_ASSERT_EQUAL(ut_params->op->status,
10091                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10092                         "Authentication failed");
10093         return 0;
10094 }
10095
10096 static int
10097 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10098 {
10099         return test_authenticated_decryption_oop(&gcm_test_case_5);
10100 }
10101
10102 static int
10103 test_authenticated_encryption_sessionless(
10104                 const struct aead_test_data *tdata)
10105 {
10106         struct crypto_testsuite_params *ts_params = &testsuite_params;
10107         struct crypto_unittest_params *ut_params = &unittest_params;
10108
10109         int retval;
10110         uint8_t *ciphertext, *auth_tag;
10111         uint16_t plaintext_pad_len;
10112         uint8_t key[tdata->key.len + 1];
10113         struct rte_cryptodev_info dev_info;
10114
10115         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10116         uint64_t feat_flags = dev_info.feature_flags;
10117
10118         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10119                 printf("Device doesn't support Sessionless ops.\n");
10120                 return TEST_SKIPPED;
10121         }
10122
10123         /* not supported with CPU crypto */
10124         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10125                 return TEST_SKIPPED;
10126
10127         /* Verify the capabilities */
10128         struct rte_cryptodev_sym_capability_idx cap_idx;
10129         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10130         cap_idx.algo.aead = tdata->algo;
10131         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10132                         &cap_idx) == NULL)
10133                 return TEST_SKIPPED;
10134
10135         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10136
10137         /* clear mbuf payload */
10138         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10139                         rte_pktmbuf_tailroom(ut_params->ibuf));
10140
10141         /* Create AEAD operation */
10142         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10143         if (retval < 0)
10144                 return retval;
10145
10146         /* Create GCM xform */
10147         memcpy(key, tdata->key.data, tdata->key.len);
10148         retval = create_aead_xform(ut_params->op,
10149                         tdata->algo,
10150                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10151                         key, tdata->key.len,
10152                         tdata->aad.len, tdata->auth_tag.len,
10153                         tdata->iv.len);
10154         if (retval < 0)
10155                 return retval;
10156
10157         ut_params->op->sym->m_src = ut_params->ibuf;
10158
10159         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10160                         RTE_CRYPTO_OP_SESSIONLESS,
10161                         "crypto op session type not sessionless");
10162
10163         /* Process crypto operation */
10164         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10165                         ut_params->op), "failed to process sym crypto op");
10166
10167         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10168
10169         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10170                         "crypto op status not success");
10171
10172         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10173
10174         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10175                         ut_params->op->sym->cipher.data.offset);
10176         auth_tag = ciphertext + plaintext_pad_len;
10177
10178         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10179         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10180
10181         /* Validate obuf */
10182         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10183                         ciphertext,
10184                         tdata->ciphertext.data,
10185                         tdata->ciphertext.len,
10186                         "Ciphertext data not as expected");
10187
10188         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10189                         auth_tag,
10190                         tdata->auth_tag.data,
10191                         tdata->auth_tag.len,
10192                         "Generated auth tag not as expected");
10193
10194         return 0;
10195
10196 }
10197
10198 static int
10199 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10200 {
10201         return test_authenticated_encryption_sessionless(
10202                         &gcm_test_case_5);
10203 }
10204
10205 static int
10206 test_authenticated_decryption_sessionless(
10207                 const struct aead_test_data *tdata)
10208 {
10209         struct crypto_testsuite_params *ts_params = &testsuite_params;
10210         struct crypto_unittest_params *ut_params = &unittest_params;
10211
10212         int retval;
10213         uint8_t *plaintext;
10214         uint8_t key[tdata->key.len + 1];
10215         struct rte_cryptodev_info dev_info;
10216
10217         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10218         uint64_t feat_flags = dev_info.feature_flags;
10219
10220         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10221                 printf("Device doesn't support Sessionless ops.\n");
10222                 return TEST_SKIPPED;
10223         }
10224
10225         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10226                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10227                 printf("Device doesn't support RAW data-path APIs.\n");
10228                 return TEST_SKIPPED;
10229         }
10230
10231         /* not supported with CPU crypto */
10232         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10233                 return TEST_SKIPPED;
10234
10235         /* Verify the capabilities */
10236         struct rte_cryptodev_sym_capability_idx cap_idx;
10237         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10238         cap_idx.algo.aead = tdata->algo;
10239         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10240                         &cap_idx) == NULL)
10241                 return TEST_SKIPPED;
10242
10243         /* alloc mbuf and set payload */
10244         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10245
10246         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10247                         rte_pktmbuf_tailroom(ut_params->ibuf));
10248
10249         /* Create AEAD operation */
10250         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10251         if (retval < 0)
10252                 return retval;
10253
10254         /* Create AEAD xform */
10255         memcpy(key, tdata->key.data, tdata->key.len);
10256         retval = create_aead_xform(ut_params->op,
10257                         tdata->algo,
10258                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10259                         key, tdata->key.len,
10260                         tdata->aad.len, tdata->auth_tag.len,
10261                         tdata->iv.len);
10262         if (retval < 0)
10263                 return retval;
10264
10265         ut_params->op->sym->m_src = ut_params->ibuf;
10266
10267         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10268                         RTE_CRYPTO_OP_SESSIONLESS,
10269                         "crypto op session type not sessionless");
10270
10271         /* Process crypto operation */
10272         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10273                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10274                                 ut_params->op, 0, 0, 0, 0);
10275         else
10276                 TEST_ASSERT_NOT_NULL(process_crypto_request(
10277                         ts_params->valid_devs[0], ut_params->op),
10278                                 "failed to process sym crypto op");
10279
10280         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10281
10282         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10283                         "crypto op status not success");
10284
10285         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10286                         ut_params->op->sym->cipher.data.offset);
10287
10288         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10289
10290         /* Validate obuf */
10291         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10292                         plaintext,
10293                         tdata->plaintext.data,
10294                         tdata->plaintext.len,
10295                         "Plaintext data not as expected");
10296
10297         TEST_ASSERT_EQUAL(ut_params->op->status,
10298                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10299                         "Authentication failed");
10300         return 0;
10301 }
10302
10303 static int
10304 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
10305 {
10306         return test_authenticated_decryption_sessionless(
10307                         &gcm_test_case_5);
10308 }
10309
10310 static int
10311 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
10312 {
10313         return test_authenticated_encryption(&ccm_test_case_128_1);
10314 }
10315
10316 static int
10317 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
10318 {
10319         return test_authenticated_encryption(&ccm_test_case_128_2);
10320 }
10321
10322 static int
10323 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
10324 {
10325         return test_authenticated_encryption(&ccm_test_case_128_3);
10326 }
10327
10328 static int
10329 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
10330 {
10331         return test_authenticated_decryption(&ccm_test_case_128_1);
10332 }
10333
10334 static int
10335 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
10336 {
10337         return test_authenticated_decryption(&ccm_test_case_128_2);
10338 }
10339
10340 static int
10341 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
10342 {
10343         return test_authenticated_decryption(&ccm_test_case_128_3);
10344 }
10345
10346 static int
10347 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
10348 {
10349         return test_authenticated_encryption(&ccm_test_case_192_1);
10350 }
10351
10352 static int
10353 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
10354 {
10355         return test_authenticated_encryption(&ccm_test_case_192_2);
10356 }
10357
10358 static int
10359 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10360 {
10361         return test_authenticated_encryption(&ccm_test_case_192_3);
10362 }
10363
10364 static int
10365 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10366 {
10367         return test_authenticated_decryption(&ccm_test_case_192_1);
10368 }
10369
10370 static int
10371 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10372 {
10373         return test_authenticated_decryption(&ccm_test_case_192_2);
10374 }
10375
10376 static int
10377 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10378 {
10379         return test_authenticated_decryption(&ccm_test_case_192_3);
10380 }
10381
10382 static int
10383 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10384 {
10385         return test_authenticated_encryption(&ccm_test_case_256_1);
10386 }
10387
10388 static int
10389 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10390 {
10391         return test_authenticated_encryption(&ccm_test_case_256_2);
10392 }
10393
10394 static int
10395 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10396 {
10397         return test_authenticated_encryption(&ccm_test_case_256_3);
10398 }
10399
10400 static int
10401 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10402 {
10403         return test_authenticated_decryption(&ccm_test_case_256_1);
10404 }
10405
10406 static int
10407 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10408 {
10409         return test_authenticated_decryption(&ccm_test_case_256_2);
10410 }
10411
10412 static int
10413 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10414 {
10415         return test_authenticated_decryption(&ccm_test_case_256_3);
10416 }
10417
10418 static int
10419 test_stats(void)
10420 {
10421         struct crypto_testsuite_params *ts_params = &testsuite_params;
10422         struct rte_cryptodev_stats stats;
10423
10424         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10425                 return TEST_SKIPPED;
10426
10427         /* Verify the capabilities */
10428         struct rte_cryptodev_sym_capability_idx cap_idx;
10429         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10430         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10431         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10432                         &cap_idx) == NULL)
10433                 return TEST_SKIPPED;
10434         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10435         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10436         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10437                         &cap_idx) == NULL)
10438                 return TEST_SKIPPED;
10439
10440         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10441                         == -ENOTSUP)
10442                 return TEST_SKIPPED;
10443
10444         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10445         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10446                         &stats) == -ENODEV),
10447                 "rte_cryptodev_stats_get invalid dev failed");
10448         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10449                 "rte_cryptodev_stats_get invalid Param failed");
10450
10451         /* Test expected values */
10452         test_AES_CBC_HMAC_SHA1_encrypt_digest();
10453         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10454                         &stats),
10455                 "rte_cryptodev_stats_get failed");
10456         TEST_ASSERT((stats.enqueued_count == 1),
10457                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10458         TEST_ASSERT((stats.dequeued_count == 1),
10459                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10460         TEST_ASSERT((stats.enqueue_err_count == 0),
10461                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10462         TEST_ASSERT((stats.dequeue_err_count == 0),
10463                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10464
10465         /* invalid device but should ignore and not reset device stats*/
10466         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10467         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10468                         &stats),
10469                 "rte_cryptodev_stats_get failed");
10470         TEST_ASSERT((stats.enqueued_count == 1),
10471                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10472
10473         /* check that a valid reset clears stats */
10474         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10475         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10476                         &stats),
10477                                           "rte_cryptodev_stats_get failed");
10478         TEST_ASSERT((stats.enqueued_count == 0),
10479                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10480         TEST_ASSERT((stats.dequeued_count == 0),
10481                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10482
10483         return TEST_SUCCESS;
10484 }
10485
10486 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10487                                    struct crypto_unittest_params *ut_params,
10488                                    enum rte_crypto_auth_operation op,
10489                                    const struct HMAC_MD5_vector *test_case)
10490 {
10491         uint8_t key[64];
10492
10493         memcpy(key, test_case->key.data, test_case->key.len);
10494
10495         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10496         ut_params->auth_xform.next = NULL;
10497         ut_params->auth_xform.auth.op = op;
10498
10499         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10500
10501         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10502         ut_params->auth_xform.auth.key.length = test_case->key.len;
10503         ut_params->auth_xform.auth.key.data = key;
10504
10505         ut_params->sess = rte_cryptodev_sym_session_create(
10506                         ts_params->session_mpool);
10507
10508         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10509                         ut_params->sess, &ut_params->auth_xform,
10510                         ts_params->session_priv_mpool);
10511
10512         if (ut_params->sess == NULL)
10513                 return TEST_FAILED;
10514
10515         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10516
10517         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10518                         rte_pktmbuf_tailroom(ut_params->ibuf));
10519
10520         return 0;
10521 }
10522
10523 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10524                               const struct HMAC_MD5_vector *test_case,
10525                               uint8_t **plaintext)
10526 {
10527         uint16_t plaintext_pad_len;
10528
10529         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10530
10531         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10532                                 16);
10533
10534         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10535                         plaintext_pad_len);
10536         memcpy(*plaintext, test_case->plaintext.data,
10537                         test_case->plaintext.len);
10538
10539         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10540                         ut_params->ibuf, MD5_DIGEST_LEN);
10541         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10542                         "no room to append digest");
10543         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10544                         ut_params->ibuf, plaintext_pad_len);
10545
10546         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10547                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10548                            test_case->auth_tag.len);
10549         }
10550
10551         sym_op->auth.data.offset = 0;
10552         sym_op->auth.data.length = test_case->plaintext.len;
10553
10554         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10555         ut_params->op->sym->m_src = ut_params->ibuf;
10556
10557         return 0;
10558 }
10559
10560 static int
10561 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10562 {
10563         uint16_t plaintext_pad_len;
10564         uint8_t *plaintext, *auth_tag;
10565
10566         struct crypto_testsuite_params *ts_params = &testsuite_params;
10567         struct crypto_unittest_params *ut_params = &unittest_params;
10568         struct rte_cryptodev_info dev_info;
10569
10570         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10571         uint64_t feat_flags = dev_info.feature_flags;
10572
10573         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10574                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10575                 printf("Device doesn't support RAW data-path APIs.\n");
10576                 return TEST_SKIPPED;
10577         }
10578
10579         /* Verify the capabilities */
10580         struct rte_cryptodev_sym_capability_idx cap_idx;
10581         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10582         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10583         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10584                         &cap_idx) == NULL)
10585                 return TEST_SKIPPED;
10586
10587         if (MD5_HMAC_create_session(ts_params, ut_params,
10588                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10589                 return TEST_FAILED;
10590
10591         /* Generate Crypto op data structure */
10592         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10593                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10594         TEST_ASSERT_NOT_NULL(ut_params->op,
10595                         "Failed to allocate symmetric crypto operation struct");
10596
10597         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10598                                 16);
10599
10600         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10601                 return TEST_FAILED;
10602
10603         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10604                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10605                         ut_params->op);
10606         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10607                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10608                                 ut_params->op, 0, 1, 0, 0);
10609         else
10610                 TEST_ASSERT_NOT_NULL(
10611                         process_crypto_request(ts_params->valid_devs[0],
10612                                 ut_params->op),
10613                                 "failed to process sym crypto op");
10614
10615         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10616                         "crypto op processing failed");
10617
10618         if (ut_params->op->sym->m_dst) {
10619                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10620                                 uint8_t *, plaintext_pad_len);
10621         } else {
10622                 auth_tag = plaintext + plaintext_pad_len;
10623         }
10624
10625         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10626                         auth_tag,
10627                         test_case->auth_tag.data,
10628                         test_case->auth_tag.len,
10629                         "HMAC_MD5 generated tag not as expected");
10630
10631         return TEST_SUCCESS;
10632 }
10633
10634 static int
10635 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10636 {
10637         uint8_t *plaintext;
10638
10639         struct crypto_testsuite_params *ts_params = &testsuite_params;
10640         struct crypto_unittest_params *ut_params = &unittest_params;
10641         struct rte_cryptodev_info dev_info;
10642
10643         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10644         uint64_t feat_flags = dev_info.feature_flags;
10645
10646         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10647                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10648                 printf("Device doesn't support RAW data-path APIs.\n");
10649                 return TEST_SKIPPED;
10650         }
10651
10652         /* Verify the capabilities */
10653         struct rte_cryptodev_sym_capability_idx cap_idx;
10654         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10655         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10656         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10657                         &cap_idx) == NULL)
10658                 return TEST_SKIPPED;
10659
10660         if (MD5_HMAC_create_session(ts_params, ut_params,
10661                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
10662                 return TEST_FAILED;
10663         }
10664
10665         /* Generate Crypto op data structure */
10666         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10667                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10668         TEST_ASSERT_NOT_NULL(ut_params->op,
10669                         "Failed to allocate symmetric crypto operation struct");
10670
10671         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10672                 return TEST_FAILED;
10673
10674         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10675                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10676                         ut_params->op);
10677         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10678                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10679                                 ut_params->op, 0, 1, 0, 0);
10680         else
10681                 TEST_ASSERT_NOT_NULL(
10682                         process_crypto_request(ts_params->valid_devs[0],
10683                                 ut_params->op),
10684                                 "failed to process sym crypto op");
10685
10686         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10687                         "HMAC_MD5 crypto op processing failed");
10688
10689         return TEST_SUCCESS;
10690 }
10691
10692 static int
10693 test_MD5_HMAC_generate_case_1(void)
10694 {
10695         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
10696 }
10697
10698 static int
10699 test_MD5_HMAC_verify_case_1(void)
10700 {
10701         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
10702 }
10703
10704 static int
10705 test_MD5_HMAC_generate_case_2(void)
10706 {
10707         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
10708 }
10709
10710 static int
10711 test_MD5_HMAC_verify_case_2(void)
10712 {
10713         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
10714 }
10715
10716 static int
10717 test_multi_session(void)
10718 {
10719         struct crypto_testsuite_params *ts_params = &testsuite_params;
10720         struct crypto_unittest_params *ut_params = &unittest_params;
10721
10722         struct rte_cryptodev_info dev_info;
10723         struct rte_cryptodev_sym_session **sessions;
10724
10725         uint16_t i;
10726
10727         /* Verify the capabilities */
10728         struct rte_cryptodev_sym_capability_idx cap_idx;
10729         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10730         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10731         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10732                         &cap_idx) == NULL)
10733                 return TEST_SKIPPED;
10734         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10735         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10736         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10737                         &cap_idx) == NULL)
10738                 return TEST_SKIPPED;
10739
10740         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
10741                         aes_cbc_key, hmac_sha512_key);
10742
10743
10744         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10745
10746         sessions = rte_malloc(NULL,
10747                         sizeof(struct rte_cryptodev_sym_session *) *
10748                         (MAX_NB_SESSIONS + 1), 0);
10749
10750         /* Create multiple crypto sessions*/
10751         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10752
10753                 sessions[i] = rte_cryptodev_sym_session_create(
10754                                 ts_params->session_mpool);
10755
10756                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10757                                 sessions[i], &ut_params->auth_xform,
10758                                 ts_params->session_priv_mpool);
10759                 TEST_ASSERT_NOT_NULL(sessions[i],
10760                                 "Session creation failed at session number %u",
10761                                 i);
10762
10763                 /* Attempt to send a request on each session */
10764                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
10765                         sessions[i],
10766                         ut_params,
10767                         ts_params,
10768                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
10769                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
10770                         aes_cbc_iv),
10771                         "Failed to perform decrypt on request number %u.", i);
10772                 /* free crypto operation structure */
10773                 if (ut_params->op)
10774                         rte_crypto_op_free(ut_params->op);
10775
10776                 /*
10777                  * free mbuf - both obuf and ibuf are usually the same,
10778                  * so check if they point at the same address is necessary,
10779                  * to avoid freeing the mbuf twice.
10780                  */
10781                 if (ut_params->obuf) {
10782                         rte_pktmbuf_free(ut_params->obuf);
10783                         if (ut_params->ibuf == ut_params->obuf)
10784                                 ut_params->ibuf = 0;
10785                         ut_params->obuf = 0;
10786                 }
10787                 if (ut_params->ibuf) {
10788                         rte_pktmbuf_free(ut_params->ibuf);
10789                         ut_params->ibuf = 0;
10790                 }
10791         }
10792
10793         sessions[i] = NULL;
10794         /* Next session create should fail */
10795         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10796                         sessions[i], &ut_params->auth_xform,
10797                         ts_params->session_priv_mpool);
10798         TEST_ASSERT_NULL(sessions[i],
10799                         "Session creation succeeded unexpectedly!");
10800
10801         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10802                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10803                                 sessions[i]);
10804                 rte_cryptodev_sym_session_free(sessions[i]);
10805         }
10806
10807         rte_free(sessions);
10808
10809         return TEST_SUCCESS;
10810 }
10811
10812 struct multi_session_params {
10813         struct crypto_unittest_params ut_params;
10814         uint8_t *cipher_key;
10815         uint8_t *hmac_key;
10816         const uint8_t *cipher;
10817         const uint8_t *digest;
10818         uint8_t *iv;
10819 };
10820
10821 #define MB_SESSION_NUMBER 3
10822
10823 static int
10824 test_multi_session_random_usage(void)
10825 {
10826         struct crypto_testsuite_params *ts_params = &testsuite_params;
10827         struct rte_cryptodev_info dev_info;
10828         struct rte_cryptodev_sym_session **sessions;
10829         uint32_t i, j;
10830         struct multi_session_params ut_paramz[] = {
10831
10832                 {
10833                         .cipher_key = ms_aes_cbc_key0,
10834                         .hmac_key = ms_hmac_key0,
10835                         .cipher = ms_aes_cbc_cipher0,
10836                         .digest = ms_hmac_digest0,
10837                         .iv = ms_aes_cbc_iv0
10838                 },
10839                 {
10840                         .cipher_key = ms_aes_cbc_key1,
10841                         .hmac_key = ms_hmac_key1,
10842                         .cipher = ms_aes_cbc_cipher1,
10843                         .digest = ms_hmac_digest1,
10844                         .iv = ms_aes_cbc_iv1
10845                 },
10846                 {
10847                         .cipher_key = ms_aes_cbc_key2,
10848                         .hmac_key = ms_hmac_key2,
10849                         .cipher = ms_aes_cbc_cipher2,
10850                         .digest = ms_hmac_digest2,
10851                         .iv = ms_aes_cbc_iv2
10852                 },
10853
10854         };
10855
10856         /* Verify the capabilities */
10857         struct rte_cryptodev_sym_capability_idx cap_idx;
10858         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10859         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10860         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10861                         &cap_idx) == NULL)
10862                 return TEST_SKIPPED;
10863         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10864         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10865         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10866                         &cap_idx) == NULL)
10867                 return TEST_SKIPPED;
10868
10869         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10870
10871         sessions = rte_malloc(NULL,
10872                         (sizeof(struct rte_cryptodev_sym_session *)
10873                                         * MAX_NB_SESSIONS) + 1, 0);
10874
10875         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10876                 sessions[i] = rte_cryptodev_sym_session_create(
10877                                 ts_params->session_mpool);
10878
10879                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
10880                                 sizeof(struct crypto_unittest_params));
10881
10882                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
10883                                 &ut_paramz[i].ut_params,
10884                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
10885
10886                 /* Create multiple crypto sessions*/
10887                 rte_cryptodev_sym_session_init(
10888                                 ts_params->valid_devs[0],
10889                                 sessions[i],
10890                                 &ut_paramz[i].ut_params.auth_xform,
10891                                 ts_params->session_priv_mpool);
10892
10893                 TEST_ASSERT_NOT_NULL(sessions[i],
10894                                 "Session creation failed at session number %u",
10895                                 i);
10896
10897         }
10898
10899         srand(time(NULL));
10900         for (i = 0; i < 40000; i++) {
10901
10902                 j = rand() % MB_SESSION_NUMBER;
10903
10904                 TEST_ASSERT_SUCCESS(
10905                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
10906                                         sessions[j],
10907                                         &ut_paramz[j].ut_params,
10908                                         ts_params, ut_paramz[j].cipher,
10909                                         ut_paramz[j].digest,
10910                                         ut_paramz[j].iv),
10911                         "Failed to perform decrypt on request number %u.", i);
10912
10913                 if (ut_paramz[j].ut_params.op)
10914                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
10915
10916                 /*
10917                  * free mbuf - both obuf and ibuf are usually the same,
10918                  * so check if they point at the same address is necessary,
10919                  * to avoid freeing the mbuf twice.
10920                  */
10921                 if (ut_paramz[j].ut_params.obuf) {
10922                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
10923                         if (ut_paramz[j].ut_params.ibuf
10924                                         == ut_paramz[j].ut_params.obuf)
10925                                 ut_paramz[j].ut_params.ibuf = 0;
10926                         ut_paramz[j].ut_params.obuf = 0;
10927                 }
10928                 if (ut_paramz[j].ut_params.ibuf) {
10929                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
10930                         ut_paramz[j].ut_params.ibuf = 0;
10931                 }
10932         }
10933
10934         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10935                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10936                                 sessions[i]);
10937                 rte_cryptodev_sym_session_free(sessions[i]);
10938         }
10939
10940         rte_free(sessions);
10941
10942         return TEST_SUCCESS;
10943 }
10944
10945 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
10946                         0xab, 0xab, 0xab, 0xab,
10947                         0xab, 0xab, 0xab, 0xab,
10948                         0xab, 0xab, 0xab, 0xab};
10949
10950 static int
10951 test_null_invalid_operation(void)
10952 {
10953         struct crypto_testsuite_params *ts_params = &testsuite_params;
10954         struct crypto_unittest_params *ut_params = &unittest_params;
10955         int ret;
10956
10957         /* This test is for NULL PMD only */
10958         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10959                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10960                 return TEST_SKIPPED;
10961
10962         /* Setup Cipher Parameters */
10963         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10964         ut_params->cipher_xform.next = NULL;
10965
10966         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10967         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10968
10969         ut_params->sess = rte_cryptodev_sym_session_create(
10970                         ts_params->session_mpool);
10971
10972         /* Create Crypto session*/
10973         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10974                         ut_params->sess, &ut_params->cipher_xform,
10975                         ts_params->session_priv_mpool);
10976         TEST_ASSERT(ret < 0,
10977                         "Session creation succeeded unexpectedly");
10978
10979
10980         /* Setup HMAC Parameters */
10981         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10982         ut_params->auth_xform.next = NULL;
10983
10984         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10985         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10986
10987         ut_params->sess = rte_cryptodev_sym_session_create(
10988                         ts_params->session_mpool);
10989
10990         /* Create Crypto session*/
10991         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10992                         ut_params->sess, &ut_params->auth_xform,
10993                         ts_params->session_priv_mpool);
10994         TEST_ASSERT(ret < 0,
10995                         "Session creation succeeded unexpectedly");
10996
10997         return TEST_SUCCESS;
10998 }
10999
11000
11001 #define NULL_BURST_LENGTH (32)
11002
11003 static int
11004 test_null_burst_operation(void)
11005 {
11006         struct crypto_testsuite_params *ts_params = &testsuite_params;
11007         struct crypto_unittest_params *ut_params = &unittest_params;
11008
11009         unsigned i, burst_len = NULL_BURST_LENGTH;
11010
11011         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11012         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11013
11014         /* This test is for NULL PMD only */
11015         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11016                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11017                 return TEST_SKIPPED;
11018
11019         /* Setup Cipher Parameters */
11020         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11021         ut_params->cipher_xform.next = &ut_params->auth_xform;
11022
11023         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11024         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11025
11026         /* Setup HMAC Parameters */
11027         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11028         ut_params->auth_xform.next = NULL;
11029
11030         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11031         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11032
11033         ut_params->sess = rte_cryptodev_sym_session_create(
11034                         ts_params->session_mpool);
11035
11036         /* Create Crypto session*/
11037         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11038                         ut_params->sess, &ut_params->cipher_xform,
11039                         ts_params->session_priv_mpool);
11040         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11041
11042         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11043                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11044                         burst_len, "failed to generate burst of crypto ops");
11045
11046         /* Generate an operation for each mbuf in burst */
11047         for (i = 0; i < burst_len; i++) {
11048                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11049
11050                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11051
11052                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11053                                 sizeof(unsigned));
11054                 *data = i;
11055
11056                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11057
11058                 burst[i]->sym->m_src = m;
11059         }
11060
11061         /* Process crypto operation */
11062         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11063                         0, burst, burst_len),
11064                         burst_len,
11065                         "Error enqueuing burst");
11066
11067         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11068                         0, burst_dequeued, burst_len),
11069                         burst_len,
11070                         "Error dequeuing burst");
11071
11072
11073         for (i = 0; i < burst_len; i++) {
11074                 TEST_ASSERT_EQUAL(
11075                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11076                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11077                                         uint32_t *),
11078                         "data not as expected");
11079
11080                 rte_pktmbuf_free(burst[i]->sym->m_src);
11081                 rte_crypto_op_free(burst[i]);
11082         }
11083
11084         return TEST_SUCCESS;
11085 }
11086
11087 static uint16_t
11088 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11089                   uint16_t nb_ops, void *user_param)
11090 {
11091         RTE_SET_USED(dev_id);
11092         RTE_SET_USED(qp_id);
11093         RTE_SET_USED(ops);
11094         RTE_SET_USED(user_param);
11095
11096         printf("crypto enqueue callback called\n");
11097         return nb_ops;
11098 }
11099
11100 static uint16_t
11101 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11102                   uint16_t nb_ops, void *user_param)
11103 {
11104         RTE_SET_USED(dev_id);
11105         RTE_SET_USED(qp_id);
11106         RTE_SET_USED(ops);
11107         RTE_SET_USED(user_param);
11108
11109         printf("crypto dequeue callback called\n");
11110         return nb_ops;
11111 }
11112
11113 /*
11114  * Thread using enqueue/dequeue callback with RCU.
11115  */
11116 static int
11117 test_enqdeq_callback_thread(void *arg)
11118 {
11119         RTE_SET_USED(arg);
11120         /* DP thread calls rte_cryptodev_enqueue_burst()/
11121          * rte_cryptodev_dequeue_burst() and invokes callback.
11122          */
11123         test_null_burst_operation();
11124         return 0;
11125 }
11126
11127 static int
11128 test_enq_callback_setup(void)
11129 {
11130         struct crypto_testsuite_params *ts_params = &testsuite_params;
11131         struct rte_cryptodev_info dev_info;
11132         struct rte_cryptodev_qp_conf qp_conf = {
11133                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11134         };
11135
11136         struct rte_cryptodev_cb *cb;
11137         uint16_t qp_id = 0;
11138
11139         /* Stop the device in case it's started so it can be configured */
11140         rte_cryptodev_stop(ts_params->valid_devs[0]);
11141
11142         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11143
11144         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11145                         &ts_params->conf),
11146                         "Failed to configure cryptodev %u",
11147                         ts_params->valid_devs[0]);
11148
11149         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11150         qp_conf.mp_session = ts_params->session_mpool;
11151         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11152
11153         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11154                         ts_params->valid_devs[0], qp_id, &qp_conf,
11155                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11156                         "Failed test for "
11157                         "rte_cryptodev_queue_pair_setup: num_inflights "
11158                         "%u on qp %u on cryptodev %u",
11159                         qp_conf.nb_descriptors, qp_id,
11160                         ts_params->valid_devs[0]);
11161
11162         /* Test with invalid crypto device */
11163         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11164                         qp_id, test_enq_callback, NULL);
11165         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11166                         "cryptodev %u did not fail",
11167                         qp_id, RTE_CRYPTO_MAX_DEVS);
11168
11169         /* Test with invalid queue pair */
11170         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11171                         dev_info.max_nb_queue_pairs + 1,
11172                         test_enq_callback, NULL);
11173         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11174                         "cryptodev %u did not fail",
11175                         dev_info.max_nb_queue_pairs + 1,
11176                         ts_params->valid_devs[0]);
11177
11178         /* Test with NULL callback */
11179         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11180                         qp_id, NULL, NULL);
11181         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11182                         "cryptodev %u did not fail",
11183                         qp_id, ts_params->valid_devs[0]);
11184
11185         /* Test with valid configuration */
11186         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11187                         qp_id, test_enq_callback, NULL);
11188         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11189                         "qp %u on cryptodev %u",
11190                         qp_id, ts_params->valid_devs[0]);
11191
11192         rte_cryptodev_start(ts_params->valid_devs[0]);
11193
11194         /* Launch a thread */
11195         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11196                                 rte_get_next_lcore(-1, 1, 0));
11197
11198         /* Wait until reader exited. */
11199         rte_eal_mp_wait_lcore();
11200
11201         /* Test with invalid crypto device */
11202         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11203                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11204                         "Expected call to fail as crypto device is invalid");
11205
11206         /* Test with invalid queue pair */
11207         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11208                         ts_params->valid_devs[0],
11209                         dev_info.max_nb_queue_pairs + 1, cb),
11210                         "Expected call to fail as queue pair is invalid");
11211
11212         /* Test with NULL callback */
11213         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11214                         ts_params->valid_devs[0], qp_id, NULL),
11215                         "Expected call to fail as callback is NULL");
11216
11217         /* Test with valid configuration */
11218         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11219                         ts_params->valid_devs[0], qp_id, cb),
11220                         "Failed test to remove callback on "
11221                         "qp %u on cryptodev %u",
11222                         qp_id, ts_params->valid_devs[0]);
11223
11224         return TEST_SUCCESS;
11225 }
11226
11227 static int
11228 test_deq_callback_setup(void)
11229 {
11230         struct crypto_testsuite_params *ts_params = &testsuite_params;
11231         struct rte_cryptodev_info dev_info;
11232         struct rte_cryptodev_qp_conf qp_conf = {
11233                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11234         };
11235
11236         struct rte_cryptodev_cb *cb;
11237         uint16_t qp_id = 0;
11238
11239         /* Stop the device in case it's started so it can be configured */
11240         rte_cryptodev_stop(ts_params->valid_devs[0]);
11241
11242         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11243
11244         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11245                         &ts_params->conf),
11246                         "Failed to configure cryptodev %u",
11247                         ts_params->valid_devs[0]);
11248
11249         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11250         qp_conf.mp_session = ts_params->session_mpool;
11251         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11252
11253         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11254                         ts_params->valid_devs[0], qp_id, &qp_conf,
11255                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11256                         "Failed test for "
11257                         "rte_cryptodev_queue_pair_setup: num_inflights "
11258                         "%u on qp %u on cryptodev %u",
11259                         qp_conf.nb_descriptors, qp_id,
11260                         ts_params->valid_devs[0]);
11261
11262         /* Test with invalid crypto device */
11263         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
11264                         qp_id, test_deq_callback, NULL);
11265         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11266                         "cryptodev %u did not fail",
11267                         qp_id, RTE_CRYPTO_MAX_DEVS);
11268
11269         /* Test with invalid queue pair */
11270         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11271                         dev_info.max_nb_queue_pairs + 1,
11272                         test_deq_callback, NULL);
11273         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11274                         "cryptodev %u did not fail",
11275                         dev_info.max_nb_queue_pairs + 1,
11276                         ts_params->valid_devs[0]);
11277
11278         /* Test with NULL callback */
11279         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11280                         qp_id, NULL, NULL);
11281         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11282                         "cryptodev %u did not fail",
11283                         qp_id, ts_params->valid_devs[0]);
11284
11285         /* Test with valid configuration */
11286         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11287                         qp_id, test_deq_callback, NULL);
11288         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11289                         "qp %u on cryptodev %u",
11290                         qp_id, ts_params->valid_devs[0]);
11291
11292         rte_cryptodev_start(ts_params->valid_devs[0]);
11293
11294         /* Launch a thread */
11295         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11296                                 rte_get_next_lcore(-1, 1, 0));
11297
11298         /* Wait until reader exited. */
11299         rte_eal_mp_wait_lcore();
11300
11301         /* Test with invalid crypto device */
11302         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11303                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11304                         "Expected call to fail as crypto device is invalid");
11305
11306         /* Test with invalid queue pair */
11307         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11308                         ts_params->valid_devs[0],
11309                         dev_info.max_nb_queue_pairs + 1, cb),
11310                         "Expected call to fail as queue pair is invalid");
11311
11312         /* Test with NULL callback */
11313         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11314                         ts_params->valid_devs[0], qp_id, NULL),
11315                         "Expected call to fail as callback is NULL");
11316
11317         /* Test with valid configuration */
11318         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
11319                         ts_params->valid_devs[0], qp_id, cb),
11320                         "Failed test to remove callback on "
11321                         "qp %u on cryptodev %u",
11322                         qp_id, ts_params->valid_devs[0]);
11323
11324         return TEST_SUCCESS;
11325 }
11326
11327 static void
11328 generate_gmac_large_plaintext(uint8_t *data)
11329 {
11330         uint16_t i;
11331
11332         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
11333                 memcpy(&data[i], &data[0], 32);
11334 }
11335
11336 static int
11337 create_gmac_operation(enum rte_crypto_auth_operation op,
11338                 const struct gmac_test_data *tdata)
11339 {
11340         struct crypto_testsuite_params *ts_params = &testsuite_params;
11341         struct crypto_unittest_params *ut_params = &unittest_params;
11342         struct rte_crypto_sym_op *sym_op;
11343
11344         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11345
11346         /* Generate Crypto op data structure */
11347         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11348                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11349         TEST_ASSERT_NOT_NULL(ut_params->op,
11350                         "Failed to allocate symmetric crypto operation struct");
11351
11352         sym_op = ut_params->op->sym;
11353
11354         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11355                         ut_params->ibuf, tdata->gmac_tag.len);
11356         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11357                         "no room to append digest");
11358
11359         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11360                         ut_params->ibuf, plaintext_pad_len);
11361
11362         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11363                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11364                                 tdata->gmac_tag.len);
11365                 debug_hexdump(stdout, "digest:",
11366                                 sym_op->auth.digest.data,
11367                                 tdata->gmac_tag.len);
11368         }
11369
11370         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11371                         uint8_t *, IV_OFFSET);
11372
11373         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11374
11375         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11376
11377         sym_op->cipher.data.length = 0;
11378         sym_op->cipher.data.offset = 0;
11379
11380         sym_op->auth.data.offset = 0;
11381         sym_op->auth.data.length = tdata->plaintext.len;
11382
11383         return 0;
11384 }
11385
11386 static int
11387 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
11388                 const struct gmac_test_data *tdata,
11389                 void *digest_mem, uint64_t digest_phys)
11390 {
11391         struct crypto_testsuite_params *ts_params = &testsuite_params;
11392         struct crypto_unittest_params *ut_params = &unittest_params;
11393         struct rte_crypto_sym_op *sym_op;
11394
11395         /* Generate Crypto op data structure */
11396         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11397                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11398         TEST_ASSERT_NOT_NULL(ut_params->op,
11399                         "Failed to allocate symmetric crypto operation struct");
11400
11401         sym_op = ut_params->op->sym;
11402
11403         sym_op->auth.digest.data = digest_mem;
11404         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11405                         "no room to append digest");
11406
11407         sym_op->auth.digest.phys_addr = digest_phys;
11408
11409         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11410                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11411                                 tdata->gmac_tag.len);
11412                 debug_hexdump(stdout, "digest:",
11413                                 sym_op->auth.digest.data,
11414                                 tdata->gmac_tag.len);
11415         }
11416
11417         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11418                         uint8_t *, IV_OFFSET);
11419
11420         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11421
11422         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11423
11424         sym_op->cipher.data.length = 0;
11425         sym_op->cipher.data.offset = 0;
11426
11427         sym_op->auth.data.offset = 0;
11428         sym_op->auth.data.length = tdata->plaintext.len;
11429
11430         return 0;
11431 }
11432
11433 static int create_gmac_session(uint8_t dev_id,
11434                 const struct gmac_test_data *tdata,
11435                 enum rte_crypto_auth_operation auth_op)
11436 {
11437         uint8_t auth_key[tdata->key.len];
11438
11439         struct crypto_testsuite_params *ts_params = &testsuite_params;
11440         struct crypto_unittest_params *ut_params = &unittest_params;
11441
11442         memcpy(auth_key, tdata->key.data, tdata->key.len);
11443
11444         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11445         ut_params->auth_xform.next = NULL;
11446
11447         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
11448         ut_params->auth_xform.auth.op = auth_op;
11449         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
11450         ut_params->auth_xform.auth.key.length = tdata->key.len;
11451         ut_params->auth_xform.auth.key.data = auth_key;
11452         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11453         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
11454
11455
11456         ut_params->sess = rte_cryptodev_sym_session_create(
11457                         ts_params->session_mpool);
11458
11459         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11460                         &ut_params->auth_xform,
11461                         ts_params->session_priv_mpool);
11462
11463         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11464
11465         return 0;
11466 }
11467
11468 static int
11469 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
11470 {
11471         struct crypto_testsuite_params *ts_params = &testsuite_params;
11472         struct crypto_unittest_params *ut_params = &unittest_params;
11473         struct rte_cryptodev_info dev_info;
11474
11475         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11476         uint64_t feat_flags = dev_info.feature_flags;
11477
11478         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11479                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11480                 printf("Device doesn't support RAW data-path APIs.\n");
11481                 return TEST_SKIPPED;
11482         }
11483
11484         int retval;
11485
11486         uint8_t *auth_tag, *plaintext;
11487         uint16_t plaintext_pad_len;
11488
11489         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11490                               "No GMAC length in the source data");
11491
11492         /* Verify the capabilities */
11493         struct rte_cryptodev_sym_capability_idx cap_idx;
11494         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11495         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11496         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11497                         &cap_idx) == NULL)
11498                 return TEST_SKIPPED;
11499
11500         retval = create_gmac_session(ts_params->valid_devs[0],
11501                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11502
11503         if (retval < 0)
11504                 return retval;
11505
11506         if (tdata->plaintext.len > MBUF_SIZE)
11507                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11508         else
11509                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11510         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11511                         "Failed to allocate input buffer in mempool");
11512
11513         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11514                         rte_pktmbuf_tailroom(ut_params->ibuf));
11515
11516         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11517         /*
11518          * Runtime generate the large plain text instead of use hard code
11519          * plain text vector. It is done to avoid create huge source file
11520          * with the test vector.
11521          */
11522         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11523                 generate_gmac_large_plaintext(tdata->plaintext.data);
11524
11525         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11526                                 plaintext_pad_len);
11527         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11528
11529         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11530         debug_hexdump(stdout, "plaintext:", plaintext,
11531                         tdata->plaintext.len);
11532
11533         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
11534                         tdata);
11535
11536         if (retval < 0)
11537                 return retval;
11538
11539         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11540
11541         ut_params->op->sym->m_src = ut_params->ibuf;
11542
11543         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11544                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11545                         ut_params->op);
11546         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11547                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11548                                 ut_params->op, 0, 1, 0, 0);
11549         else
11550                 TEST_ASSERT_NOT_NULL(
11551                         process_crypto_request(ts_params->valid_devs[0],
11552                         ut_params->op), "failed to process sym crypto op");
11553
11554         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11555                         "crypto op processing failed");
11556
11557         if (ut_params->op->sym->m_dst) {
11558                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11559                                 uint8_t *, plaintext_pad_len);
11560         } else {
11561                 auth_tag = plaintext + plaintext_pad_len;
11562         }
11563
11564         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11565
11566         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11567                         auth_tag,
11568                         tdata->gmac_tag.data,
11569                         tdata->gmac_tag.len,
11570                         "GMAC Generated auth tag not as expected");
11571
11572         return 0;
11573 }
11574
11575 static int
11576 test_AES_GMAC_authentication_test_case_1(void)
11577 {
11578         return test_AES_GMAC_authentication(&gmac_test_case_1);
11579 }
11580
11581 static int
11582 test_AES_GMAC_authentication_test_case_2(void)
11583 {
11584         return test_AES_GMAC_authentication(&gmac_test_case_2);
11585 }
11586
11587 static int
11588 test_AES_GMAC_authentication_test_case_3(void)
11589 {
11590         return test_AES_GMAC_authentication(&gmac_test_case_3);
11591 }
11592
11593 static int
11594 test_AES_GMAC_authentication_test_case_4(void)
11595 {
11596         return test_AES_GMAC_authentication(&gmac_test_case_4);
11597 }
11598
11599 static int
11600 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11601 {
11602         struct crypto_testsuite_params *ts_params = &testsuite_params;
11603         struct crypto_unittest_params *ut_params = &unittest_params;
11604         int retval;
11605         uint32_t plaintext_pad_len;
11606         uint8_t *plaintext;
11607         struct rte_cryptodev_info dev_info;
11608
11609         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11610         uint64_t feat_flags = dev_info.feature_flags;
11611
11612         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11613                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11614                 printf("Device doesn't support RAW data-path APIs.\n");
11615                 return TEST_SKIPPED;
11616         }
11617
11618         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11619                               "No GMAC length in the source data");
11620
11621         /* Verify the capabilities */
11622         struct rte_cryptodev_sym_capability_idx cap_idx;
11623         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11624         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11625         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11626                         &cap_idx) == NULL)
11627                 return TEST_SKIPPED;
11628
11629         retval = create_gmac_session(ts_params->valid_devs[0],
11630                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11631
11632         if (retval < 0)
11633                 return retval;
11634
11635         if (tdata->plaintext.len > MBUF_SIZE)
11636                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11637         else
11638                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11639         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11640                         "Failed to allocate input buffer in mempool");
11641
11642         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11643                         rte_pktmbuf_tailroom(ut_params->ibuf));
11644
11645         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11646
11647         /*
11648          * Runtime generate the large plain text instead of use hard code
11649          * plain text vector. It is done to avoid create huge source file
11650          * with the test vector.
11651          */
11652         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11653                 generate_gmac_large_plaintext(tdata->plaintext.data);
11654
11655         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11656                                 plaintext_pad_len);
11657         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11658
11659         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11660         debug_hexdump(stdout, "plaintext:", plaintext,
11661                         tdata->plaintext.len);
11662
11663         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
11664                         tdata);
11665
11666         if (retval < 0)
11667                 return retval;
11668
11669         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11670
11671         ut_params->op->sym->m_src = ut_params->ibuf;
11672
11673         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11674                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11675                         ut_params->op);
11676         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11677                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11678                                 ut_params->op, 0, 1, 0, 0);
11679         else
11680                 TEST_ASSERT_NOT_NULL(
11681                         process_crypto_request(ts_params->valid_devs[0],
11682                         ut_params->op), "failed to process sym crypto op");
11683
11684         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11685                         "crypto op processing failed");
11686
11687         return 0;
11688
11689 }
11690
11691 static int
11692 test_AES_GMAC_authentication_verify_test_case_1(void)
11693 {
11694         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
11695 }
11696
11697 static int
11698 test_AES_GMAC_authentication_verify_test_case_2(void)
11699 {
11700         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
11701 }
11702
11703 static int
11704 test_AES_GMAC_authentication_verify_test_case_3(void)
11705 {
11706         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
11707 }
11708
11709 static int
11710 test_AES_GMAC_authentication_verify_test_case_4(void)
11711 {
11712         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
11713 }
11714
11715 static int
11716 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
11717                                 uint32_t fragsz)
11718 {
11719         struct crypto_testsuite_params *ts_params = &testsuite_params;
11720         struct crypto_unittest_params *ut_params = &unittest_params;
11721         struct rte_cryptodev_info dev_info;
11722         uint64_t feature_flags;
11723         unsigned int trn_data = 0;
11724         void *digest_mem = NULL;
11725         uint32_t segs = 1;
11726         unsigned int to_trn = 0;
11727         struct rte_mbuf *buf = NULL;
11728         uint8_t *auth_tag, *plaintext;
11729         int retval;
11730
11731         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11732                               "No GMAC length in the source data");
11733
11734         /* Verify the capabilities */
11735         struct rte_cryptodev_sym_capability_idx cap_idx;
11736         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11737         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11738         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11739                         &cap_idx) == NULL)
11740                 return TEST_SKIPPED;
11741
11742         /* Check for any input SGL support */
11743         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11744         feature_flags = dev_info.feature_flags;
11745
11746         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
11747                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
11748                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
11749                 return TEST_SKIPPED;
11750
11751         if (fragsz > tdata->plaintext.len)
11752                 fragsz = tdata->plaintext.len;
11753
11754         uint16_t plaintext_len = fragsz;
11755
11756         retval = create_gmac_session(ts_params->valid_devs[0],
11757                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11758
11759         if (retval < 0)
11760                 return retval;
11761
11762         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11763         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11764                         "Failed to allocate input buffer in mempool");
11765
11766         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11767                         rte_pktmbuf_tailroom(ut_params->ibuf));
11768
11769         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11770                                 plaintext_len);
11771         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11772
11773         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11774
11775         trn_data += plaintext_len;
11776
11777         buf = ut_params->ibuf;
11778
11779         /*
11780          * Loop until no more fragments
11781          */
11782
11783         while (trn_data < tdata->plaintext.len) {
11784                 ++segs;
11785                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11786                                 (tdata->plaintext.len - trn_data) : fragsz;
11787
11788                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11789                 buf = buf->next;
11790
11791                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11792                                 rte_pktmbuf_tailroom(buf));
11793
11794                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11795                                 to_trn);
11796
11797                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11798                                 to_trn);
11799                 trn_data += to_trn;
11800                 if (trn_data  == tdata->plaintext.len)
11801                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11802                                         tdata->gmac_tag.len);
11803         }
11804         ut_params->ibuf->nb_segs = segs;
11805
11806         /*
11807          * Place digest at the end of the last buffer
11808          */
11809         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11810
11811         if (!digest_mem) {
11812                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11813                                 + tdata->gmac_tag.len);
11814                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11815                                 tdata->plaintext.len);
11816         }
11817
11818         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
11819                         tdata, digest_mem, digest_phys);
11820
11821         if (retval < 0)
11822                 return retval;
11823
11824         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11825
11826         ut_params->op->sym->m_src = ut_params->ibuf;
11827
11828         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11829                 return TEST_SKIPPED;
11830
11831         TEST_ASSERT_NOT_NULL(
11832                 process_crypto_request(ts_params->valid_devs[0],
11833                 ut_params->op), "failed to process sym crypto op");
11834
11835         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11836                         "crypto op processing failed");
11837
11838         auth_tag = digest_mem;
11839         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11840         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11841                         auth_tag,
11842                         tdata->gmac_tag.data,
11843                         tdata->gmac_tag.len,
11844                         "GMAC Generated auth tag not as expected");
11845
11846         return 0;
11847 }
11848
11849 /* Segment size not multiple of block size (16B) */
11850 static int
11851 test_AES_GMAC_authentication_SGL_40B(void)
11852 {
11853         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
11854 }
11855
11856 static int
11857 test_AES_GMAC_authentication_SGL_80B(void)
11858 {
11859         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
11860 }
11861
11862 static int
11863 test_AES_GMAC_authentication_SGL_2048B(void)
11864 {
11865         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
11866 }
11867
11868 /* Segment size not multiple of block size (16B) */
11869 static int
11870 test_AES_GMAC_authentication_SGL_2047B(void)
11871 {
11872         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
11873 }
11874
11875 struct test_crypto_vector {
11876         enum rte_crypto_cipher_algorithm crypto_algo;
11877         unsigned int cipher_offset;
11878         unsigned int cipher_len;
11879
11880         struct {
11881                 uint8_t data[64];
11882                 unsigned int len;
11883         } cipher_key;
11884
11885         struct {
11886                 uint8_t data[64];
11887                 unsigned int len;
11888         } iv;
11889
11890         struct {
11891                 const uint8_t *data;
11892                 unsigned int len;
11893         } plaintext;
11894
11895         struct {
11896                 const uint8_t *data;
11897                 unsigned int len;
11898         } ciphertext;
11899
11900         enum rte_crypto_auth_algorithm auth_algo;
11901         unsigned int auth_offset;
11902
11903         struct {
11904                 uint8_t data[128];
11905                 unsigned int len;
11906         } auth_key;
11907
11908         struct {
11909                 const uint8_t *data;
11910                 unsigned int len;
11911         } aad;
11912
11913         struct {
11914                 uint8_t data[128];
11915                 unsigned int len;
11916         } digest;
11917 };
11918
11919 static const struct test_crypto_vector
11920 hmac_sha1_test_crypto_vector = {
11921         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11922         .plaintext = {
11923                 .data = plaintext_hash,
11924                 .len = 512
11925         },
11926         .auth_key = {
11927                 .data = {
11928                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11929                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11930                         0xDE, 0xF4, 0xDE, 0xAD
11931                 },
11932                 .len = 20
11933         },
11934         .digest = {
11935                 .data = {
11936                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
11937                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
11938                         0x3F, 0x91, 0x64, 0x59
11939                 },
11940                 .len = 20
11941         }
11942 };
11943
11944 static const struct test_crypto_vector
11945 aes128_gmac_test_vector = {
11946         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
11947         .plaintext = {
11948                 .data = plaintext_hash,
11949                 .len = 512
11950         },
11951         .iv = {
11952                 .data = {
11953                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11954                         0x08, 0x09, 0x0A, 0x0B
11955                 },
11956                 .len = 12
11957         },
11958         .auth_key = {
11959                 .data = {
11960                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11961                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
11962                 },
11963                 .len = 16
11964         },
11965         .digest = {
11966                 .data = {
11967                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
11968                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
11969                 },
11970                 .len = 16
11971         }
11972 };
11973
11974 static const struct test_crypto_vector
11975 aes128cbc_hmac_sha1_test_vector = {
11976         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11977         .cipher_offset = 0,
11978         .cipher_len = 512,
11979         .cipher_key = {
11980                 .data = {
11981                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11982                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11983                 },
11984                 .len = 16
11985         },
11986         .iv = {
11987                 .data = {
11988                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11989                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11990                 },
11991                 .len = 16
11992         },
11993         .plaintext = {
11994                 .data = plaintext_hash,
11995                 .len = 512
11996         },
11997         .ciphertext = {
11998                 .data = ciphertext512_aes128cbc,
11999                 .len = 512
12000         },
12001         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12002         .auth_offset = 0,
12003         .auth_key = {
12004                 .data = {
12005                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12006                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12007                         0xDE, 0xF4, 0xDE, 0xAD
12008                 },
12009                 .len = 20
12010         },
12011         .digest = {
12012                 .data = {
12013                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12014                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12015                         0x18, 0x8C, 0x1D, 0x32
12016                 },
12017                 .len = 20
12018         }
12019 };
12020
12021 static const struct test_crypto_vector
12022 aes128cbc_hmac_sha1_aad_test_vector = {
12023         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12024         .cipher_offset = 8,
12025         .cipher_len = 496,
12026         .cipher_key = {
12027                 .data = {
12028                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12029                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12030                 },
12031                 .len = 16
12032         },
12033         .iv = {
12034                 .data = {
12035                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12036                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12037                 },
12038                 .len = 16
12039         },
12040         .plaintext = {
12041                 .data = plaintext_hash,
12042                 .len = 512
12043         },
12044         .ciphertext = {
12045                 .data = ciphertext512_aes128cbc_aad,
12046                 .len = 512
12047         },
12048         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12049         .auth_offset = 0,
12050         .auth_key = {
12051                 .data = {
12052                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12053                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12054                         0xDE, 0xF4, 0xDE, 0xAD
12055                 },
12056                 .len = 20
12057         },
12058         .digest = {
12059                 .data = {
12060                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12061                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12062                         0x62, 0x0F, 0xFB, 0x10
12063                 },
12064                 .len = 20
12065         }
12066 };
12067
12068 static void
12069 data_corruption(uint8_t *data)
12070 {
12071         data[0] += 1;
12072 }
12073
12074 static void
12075 tag_corruption(uint8_t *data, unsigned int tag_offset)
12076 {
12077         data[tag_offset] += 1;
12078 }
12079
12080 static int
12081 create_auth_session(struct crypto_unittest_params *ut_params,
12082                 uint8_t dev_id,
12083                 const struct test_crypto_vector *reference,
12084                 enum rte_crypto_auth_operation auth_op)
12085 {
12086         struct crypto_testsuite_params *ts_params = &testsuite_params;
12087         uint8_t auth_key[reference->auth_key.len + 1];
12088
12089         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12090
12091         /* Setup Authentication Parameters */
12092         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12093         ut_params->auth_xform.auth.op = auth_op;
12094         ut_params->auth_xform.next = NULL;
12095         ut_params->auth_xform.auth.algo = reference->auth_algo;
12096         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12097         ut_params->auth_xform.auth.key.data = auth_key;
12098         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12099
12100         /* Create Crypto session*/
12101         ut_params->sess = rte_cryptodev_sym_session_create(
12102                         ts_params->session_mpool);
12103
12104         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12105                                 &ut_params->auth_xform,
12106                                 ts_params->session_priv_mpool);
12107
12108         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12109
12110         return 0;
12111 }
12112
12113 static int
12114 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12115                 uint8_t dev_id,
12116                 const struct test_crypto_vector *reference,
12117                 enum rte_crypto_auth_operation auth_op,
12118                 enum rte_crypto_cipher_operation cipher_op)
12119 {
12120         struct crypto_testsuite_params *ts_params = &testsuite_params;
12121         uint8_t cipher_key[reference->cipher_key.len + 1];
12122         uint8_t auth_key[reference->auth_key.len + 1];
12123
12124         memcpy(cipher_key, reference->cipher_key.data,
12125                         reference->cipher_key.len);
12126         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12127
12128         /* Setup Authentication Parameters */
12129         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12130         ut_params->auth_xform.auth.op = auth_op;
12131         ut_params->auth_xform.auth.algo = reference->auth_algo;
12132         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12133         ut_params->auth_xform.auth.key.data = auth_key;
12134         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12135
12136         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12137                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12138                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12139         } else {
12140                 ut_params->auth_xform.next = &ut_params->cipher_xform;
12141
12142                 /* Setup Cipher Parameters */
12143                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12144                 ut_params->cipher_xform.next = NULL;
12145                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12146                 ut_params->cipher_xform.cipher.op = cipher_op;
12147                 ut_params->cipher_xform.cipher.key.data = cipher_key;
12148                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12149                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12150                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12151         }
12152
12153         /* Create Crypto session*/
12154         ut_params->sess = rte_cryptodev_sym_session_create(
12155                         ts_params->session_mpool);
12156
12157         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12158                                 &ut_params->auth_xform,
12159                                 ts_params->session_priv_mpool);
12160
12161         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12162
12163         return 0;
12164 }
12165
12166 static int
12167 create_auth_operation(struct crypto_testsuite_params *ts_params,
12168                 struct crypto_unittest_params *ut_params,
12169                 const struct test_crypto_vector *reference,
12170                 unsigned int auth_generate)
12171 {
12172         /* Generate Crypto op data structure */
12173         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12174                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12175         TEST_ASSERT_NOT_NULL(ut_params->op,
12176                         "Failed to allocate pktmbuf offload");
12177
12178         /* Set crypto operation data parameters */
12179         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12180
12181         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12182
12183         /* set crypto operation source mbuf */
12184         sym_op->m_src = ut_params->ibuf;
12185
12186         /* digest */
12187         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12188                         ut_params->ibuf, reference->digest.len);
12189
12190         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12191                         "no room to append auth tag");
12192
12193         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12194                         ut_params->ibuf, reference->plaintext.len);
12195
12196         if (auth_generate)
12197                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12198         else
12199                 memcpy(sym_op->auth.digest.data,
12200                                 reference->digest.data,
12201                                 reference->digest.len);
12202
12203         debug_hexdump(stdout, "digest:",
12204                         sym_op->auth.digest.data,
12205                         reference->digest.len);
12206
12207         sym_op->auth.data.length = reference->plaintext.len;
12208         sym_op->auth.data.offset = 0;
12209
12210         return 0;
12211 }
12212
12213 static int
12214 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12215                 struct crypto_unittest_params *ut_params,
12216                 const struct test_crypto_vector *reference,
12217                 unsigned int auth_generate)
12218 {
12219         /* Generate Crypto op data structure */
12220         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12221                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12222         TEST_ASSERT_NOT_NULL(ut_params->op,
12223                         "Failed to allocate pktmbuf offload");
12224
12225         /* Set crypto operation data parameters */
12226         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12227
12228         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12229
12230         /* set crypto operation source mbuf */
12231         sym_op->m_src = ut_params->ibuf;
12232
12233         /* digest */
12234         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12235                         ut_params->ibuf, reference->digest.len);
12236
12237         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12238                         "no room to append auth tag");
12239
12240         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12241                         ut_params->ibuf, reference->ciphertext.len);
12242
12243         if (auth_generate)
12244                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12245         else
12246                 memcpy(sym_op->auth.digest.data,
12247                                 reference->digest.data,
12248                                 reference->digest.len);
12249
12250         debug_hexdump(stdout, "digest:",
12251                         sym_op->auth.digest.data,
12252                         reference->digest.len);
12253
12254         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12255                         reference->iv.data, reference->iv.len);
12256
12257         sym_op->cipher.data.length = 0;
12258         sym_op->cipher.data.offset = 0;
12259
12260         sym_op->auth.data.length = reference->plaintext.len;
12261         sym_op->auth.data.offset = 0;
12262
12263         return 0;
12264 }
12265
12266 static int
12267 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
12268                 struct crypto_unittest_params *ut_params,
12269                 const struct test_crypto_vector *reference,
12270                 unsigned int auth_generate)
12271 {
12272         /* Generate Crypto op data structure */
12273         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12274                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12275         TEST_ASSERT_NOT_NULL(ut_params->op,
12276                         "Failed to allocate pktmbuf offload");
12277
12278         /* Set crypto operation data parameters */
12279         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12280
12281         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12282
12283         /* set crypto operation source mbuf */
12284         sym_op->m_src = ut_params->ibuf;
12285
12286         /* digest */
12287         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12288                         ut_params->ibuf, reference->digest.len);
12289
12290         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12291                         "no room to append auth tag");
12292
12293         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12294                         ut_params->ibuf, reference->ciphertext.len);
12295
12296         if (auth_generate)
12297                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12298         else
12299                 memcpy(sym_op->auth.digest.data,
12300                                 reference->digest.data,
12301                                 reference->digest.len);
12302
12303         debug_hexdump(stdout, "digest:",
12304                         sym_op->auth.digest.data,
12305                         reference->digest.len);
12306
12307         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12308                         reference->iv.data, reference->iv.len);
12309
12310         sym_op->cipher.data.length = reference->cipher_len;
12311         sym_op->cipher.data.offset = reference->cipher_offset;
12312
12313         sym_op->auth.data.length = reference->plaintext.len;
12314         sym_op->auth.data.offset = reference->auth_offset;
12315
12316         return 0;
12317 }
12318
12319 static int
12320 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12321                 struct crypto_unittest_params *ut_params,
12322                 const struct test_crypto_vector *reference)
12323 {
12324         return create_auth_operation(ts_params, ut_params, reference, 0);
12325 }
12326
12327 static int
12328 create_auth_verify_GMAC_operation(
12329                 struct crypto_testsuite_params *ts_params,
12330                 struct crypto_unittest_params *ut_params,
12331                 const struct test_crypto_vector *reference)
12332 {
12333         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
12334 }
12335
12336 static int
12337 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12338                 struct crypto_unittest_params *ut_params,
12339                 const struct test_crypto_vector *reference)
12340 {
12341         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
12342 }
12343
12344 static int
12345 test_authentication_verify_fail_when_data_corruption(
12346                 struct crypto_testsuite_params *ts_params,
12347                 struct crypto_unittest_params *ut_params,
12348                 const struct test_crypto_vector *reference,
12349                 unsigned int data_corrupted)
12350 {
12351         int retval;
12352
12353         uint8_t *plaintext;
12354         struct rte_cryptodev_info dev_info;
12355
12356         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12357         uint64_t feat_flags = dev_info.feature_flags;
12358
12359         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12360                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12361                 printf("Device doesn't support RAW data-path APIs.\n");
12362                 return TEST_SKIPPED;
12363         }
12364
12365         /* Verify the capabilities */
12366         struct rte_cryptodev_sym_capability_idx cap_idx;
12367         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12368         cap_idx.algo.auth = reference->auth_algo;
12369         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12370                         &cap_idx) == NULL)
12371                 return TEST_SKIPPED;
12372
12373
12374         /* Create session */
12375         retval = create_auth_session(ut_params,
12376                         ts_params->valid_devs[0],
12377                         reference,
12378                         RTE_CRYPTO_AUTH_OP_VERIFY);
12379         if (retval < 0)
12380                 return retval;
12381
12382         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12383         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12384                         "Failed to allocate input buffer in mempool");
12385
12386         /* clear mbuf payload */
12387         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12388                         rte_pktmbuf_tailroom(ut_params->ibuf));
12389
12390         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12391                         reference->plaintext.len);
12392         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12393         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12394
12395         debug_hexdump(stdout, "plaintext:", plaintext,
12396                 reference->plaintext.len);
12397
12398         /* Create operation */
12399         retval = create_auth_verify_operation(ts_params, ut_params, reference);
12400
12401         if (retval < 0)
12402                 return retval;
12403
12404         if (data_corrupted)
12405                 data_corruption(plaintext);
12406         else
12407                 tag_corruption(plaintext, reference->plaintext.len);
12408
12409         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12410                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12411                         ut_params->op);
12412                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12413                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12414                         "authentication not failed");
12415         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12416                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12417                                 ut_params->op, 0, 1, 0, 0);
12418         else {
12419                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12420                         ut_params->op);
12421                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12422         }
12423
12424         return 0;
12425 }
12426
12427 static int
12428 test_authentication_verify_GMAC_fail_when_corruption(
12429                 struct crypto_testsuite_params *ts_params,
12430                 struct crypto_unittest_params *ut_params,
12431                 const struct test_crypto_vector *reference,
12432                 unsigned int data_corrupted)
12433 {
12434         int retval;
12435         uint8_t *plaintext;
12436         struct rte_cryptodev_info dev_info;
12437
12438         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12439         uint64_t feat_flags = dev_info.feature_flags;
12440
12441         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12442                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12443                 printf("Device doesn't support RAW data-path APIs.\n");
12444                 return TEST_SKIPPED;
12445         }
12446
12447         /* Verify the capabilities */
12448         struct rte_cryptodev_sym_capability_idx cap_idx;
12449         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12450         cap_idx.algo.auth = reference->auth_algo;
12451         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12452                         &cap_idx) == NULL)
12453                 return TEST_SKIPPED;
12454
12455         /* Create session */
12456         retval = create_auth_cipher_session(ut_params,
12457                         ts_params->valid_devs[0],
12458                         reference,
12459                         RTE_CRYPTO_AUTH_OP_VERIFY,
12460                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
12461         if (retval < 0)
12462                 return retval;
12463
12464         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12465         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12466                         "Failed to allocate input buffer in mempool");
12467
12468         /* clear mbuf payload */
12469         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12470                         rte_pktmbuf_tailroom(ut_params->ibuf));
12471
12472         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12473                         reference->plaintext.len);
12474         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12475         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12476
12477         debug_hexdump(stdout, "plaintext:", plaintext,
12478                 reference->plaintext.len);
12479
12480         /* Create operation */
12481         retval = create_auth_verify_GMAC_operation(ts_params,
12482                         ut_params,
12483                         reference);
12484
12485         if (retval < 0)
12486                 return retval;
12487
12488         if (data_corrupted)
12489                 data_corruption(plaintext);
12490         else
12491                 tag_corruption(plaintext, reference->aad.len);
12492
12493         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12494                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12495                         ut_params->op);
12496                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12497                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12498                         "authentication not failed");
12499         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12500                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12501                                 ut_params->op, 0, 1, 0, 0);
12502         else {
12503                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12504                         ut_params->op);
12505                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12506         }
12507
12508         return 0;
12509 }
12510
12511 static int
12512 test_authenticated_decryption_fail_when_corruption(
12513                 struct crypto_testsuite_params *ts_params,
12514                 struct crypto_unittest_params *ut_params,
12515                 const struct test_crypto_vector *reference,
12516                 unsigned int data_corrupted)
12517 {
12518         int retval;
12519
12520         uint8_t *ciphertext;
12521         struct rte_cryptodev_info dev_info;
12522
12523         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12524         uint64_t feat_flags = dev_info.feature_flags;
12525
12526         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12527                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12528                 printf("Device doesn't support RAW data-path APIs.\n");
12529                 return TEST_SKIPPED;
12530         }
12531
12532         /* Verify the capabilities */
12533         struct rte_cryptodev_sym_capability_idx cap_idx;
12534         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12535         cap_idx.algo.auth = reference->auth_algo;
12536         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12537                         &cap_idx) == NULL)
12538                 return TEST_SKIPPED;
12539         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12540         cap_idx.algo.cipher = reference->crypto_algo;
12541         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12542                         &cap_idx) == NULL)
12543                 return TEST_SKIPPED;
12544
12545         /* Create session */
12546         retval = create_auth_cipher_session(ut_params,
12547                         ts_params->valid_devs[0],
12548                         reference,
12549                         RTE_CRYPTO_AUTH_OP_VERIFY,
12550                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
12551         if (retval < 0)
12552                 return retval;
12553
12554         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12555         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12556                         "Failed to allocate input buffer in mempool");
12557
12558         /* clear mbuf payload */
12559         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12560                         rte_pktmbuf_tailroom(ut_params->ibuf));
12561
12562         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12563                         reference->ciphertext.len);
12564         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12565         memcpy(ciphertext, reference->ciphertext.data,
12566                         reference->ciphertext.len);
12567
12568         /* Create operation */
12569         retval = create_cipher_auth_verify_operation(ts_params,
12570                         ut_params,
12571                         reference);
12572
12573         if (retval < 0)
12574                 return retval;
12575
12576         if (data_corrupted)
12577                 data_corruption(ciphertext);
12578         else
12579                 tag_corruption(ciphertext, reference->ciphertext.len);
12580
12581         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12582                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12583                         ut_params->op);
12584                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12585                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12586                         "authentication not failed");
12587         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12588                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12589                                 ut_params->op, 1, 1, 0, 0);
12590         else {
12591                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12592                         ut_params->op);
12593                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12594         }
12595
12596         return 0;
12597 }
12598
12599 static int
12600 test_authenticated_encrypt_with_esn(
12601                 struct crypto_testsuite_params *ts_params,
12602                 struct crypto_unittest_params *ut_params,
12603                 const struct test_crypto_vector *reference)
12604 {
12605         int retval;
12606
12607         uint8_t *authciphertext, *plaintext, *auth_tag;
12608         uint16_t plaintext_pad_len;
12609         uint8_t cipher_key[reference->cipher_key.len + 1];
12610         uint8_t auth_key[reference->auth_key.len + 1];
12611         struct rte_cryptodev_info dev_info;
12612
12613         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12614         uint64_t feat_flags = dev_info.feature_flags;
12615
12616         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12617                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12618                 printf("Device doesn't support RAW data-path APIs.\n");
12619                 return TEST_SKIPPED;
12620         }
12621
12622         /* Verify the capabilities */
12623         struct rte_cryptodev_sym_capability_idx cap_idx;
12624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12625         cap_idx.algo.auth = reference->auth_algo;
12626         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12627                         &cap_idx) == NULL)
12628                 return TEST_SKIPPED;
12629         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12630         cap_idx.algo.cipher = reference->crypto_algo;
12631         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12632                         &cap_idx) == NULL)
12633                 return TEST_SKIPPED;
12634
12635         /* Create session */
12636         memcpy(cipher_key, reference->cipher_key.data,
12637                         reference->cipher_key.len);
12638         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12639
12640         /* Setup Cipher Parameters */
12641         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12642         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12643         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12644         ut_params->cipher_xform.cipher.key.data = cipher_key;
12645         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12646         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12647         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12648
12649         ut_params->cipher_xform.next = &ut_params->auth_xform;
12650
12651         /* Setup Authentication Parameters */
12652         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12653         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12654         ut_params->auth_xform.auth.algo = reference->auth_algo;
12655         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12656         ut_params->auth_xform.auth.key.data = auth_key;
12657         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12658         ut_params->auth_xform.next = NULL;
12659
12660         /* Create Crypto session*/
12661         ut_params->sess = rte_cryptodev_sym_session_create(
12662                         ts_params->session_mpool);
12663
12664         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12665                                 ut_params->sess,
12666                                 &ut_params->cipher_xform,
12667                                 ts_params->session_priv_mpool);
12668
12669         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12670
12671         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12672         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12673                         "Failed to allocate input buffer in mempool");
12674
12675         /* clear mbuf payload */
12676         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12677                         rte_pktmbuf_tailroom(ut_params->ibuf));
12678
12679         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12680                         reference->plaintext.len);
12681         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12682         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12683
12684         /* Create operation */
12685         retval = create_cipher_auth_operation(ts_params,
12686                         ut_params,
12687                         reference, 0);
12688
12689         if (retval < 0)
12690                 return retval;
12691
12692         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12693                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12694                         ut_params->op);
12695         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12696                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12697                                 ut_params->op, 1, 1, 0, 0);
12698         else
12699                 ut_params->op = process_crypto_request(
12700                         ts_params->valid_devs[0], ut_params->op);
12701
12702         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
12703
12704         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12705                         "crypto op processing failed");
12706
12707         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
12708
12709         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
12710                         ut_params->op->sym->auth.data.offset);
12711         auth_tag = authciphertext + plaintext_pad_len;
12712         debug_hexdump(stdout, "ciphertext:", authciphertext,
12713                         reference->ciphertext.len);
12714         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
12715
12716         /* Validate obuf */
12717         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12718                         authciphertext,
12719                         reference->ciphertext.data,
12720                         reference->ciphertext.len,
12721                         "Ciphertext data not as expected");
12722
12723         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12724                         auth_tag,
12725                         reference->digest.data,
12726                         reference->digest.len,
12727                         "Generated digest not as expected");
12728
12729         return TEST_SUCCESS;
12730
12731 }
12732
12733 static int
12734 test_authenticated_decrypt_with_esn(
12735                 struct crypto_testsuite_params *ts_params,
12736                 struct crypto_unittest_params *ut_params,
12737                 const struct test_crypto_vector *reference)
12738 {
12739         int retval;
12740
12741         uint8_t *ciphertext;
12742         uint8_t cipher_key[reference->cipher_key.len + 1];
12743         uint8_t auth_key[reference->auth_key.len + 1];
12744         struct rte_cryptodev_info dev_info;
12745
12746         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12747         uint64_t feat_flags = dev_info.feature_flags;
12748
12749         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12750                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12751                 printf("Device doesn't support RAW data-path APIs.\n");
12752                 return TEST_SKIPPED;
12753         }
12754
12755         /* Verify the capabilities */
12756         struct rte_cryptodev_sym_capability_idx cap_idx;
12757         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12758         cap_idx.algo.auth = reference->auth_algo;
12759         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12760                         &cap_idx) == NULL)
12761                 return TEST_SKIPPED;
12762         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12763         cap_idx.algo.cipher = reference->crypto_algo;
12764         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12765                         &cap_idx) == NULL)
12766                 return TEST_SKIPPED;
12767
12768         /* Create session */
12769         memcpy(cipher_key, reference->cipher_key.data,
12770                         reference->cipher_key.len);
12771         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12772
12773         /* Setup Authentication Parameters */
12774         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12775         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
12776         ut_params->auth_xform.auth.algo = reference->auth_algo;
12777         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12778         ut_params->auth_xform.auth.key.data = auth_key;
12779         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12780         ut_params->auth_xform.next = &ut_params->cipher_xform;
12781
12782         /* Setup Cipher Parameters */
12783         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12784         ut_params->cipher_xform.next = NULL;
12785         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12786         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
12787         ut_params->cipher_xform.cipher.key.data = cipher_key;
12788         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12789         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12790         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12791
12792         /* Create Crypto session*/
12793         ut_params->sess = rte_cryptodev_sym_session_create(
12794                         ts_params->session_mpool);
12795
12796         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12797                                 ut_params->sess,
12798                                 &ut_params->auth_xform,
12799                                 ts_params->session_priv_mpool);
12800
12801         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12802
12803         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12804         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12805                         "Failed to allocate input buffer in mempool");
12806
12807         /* clear mbuf payload */
12808         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12809                         rte_pktmbuf_tailroom(ut_params->ibuf));
12810
12811         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12812                         reference->ciphertext.len);
12813         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12814         memcpy(ciphertext, reference->ciphertext.data,
12815                         reference->ciphertext.len);
12816
12817         /* Create operation */
12818         retval = create_cipher_auth_verify_operation(ts_params,
12819                         ut_params,
12820                         reference);
12821
12822         if (retval < 0)
12823                 return retval;
12824
12825         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12826                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12827                         ut_params->op);
12828         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12829                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12830                                 ut_params->op, 1, 1, 0, 0);
12831         else
12832                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12833                         ut_params->op);
12834
12835         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
12836         TEST_ASSERT_EQUAL(ut_params->op->status,
12837                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12838                         "crypto op processing passed");
12839
12840         ut_params->obuf = ut_params->op->sym->m_src;
12841         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
12842
12843         return 0;
12844 }
12845
12846 static int
12847 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
12848                 const struct aead_test_data *tdata,
12849                 void *digest_mem, uint64_t digest_phys)
12850 {
12851         struct crypto_testsuite_params *ts_params = &testsuite_params;
12852         struct crypto_unittest_params *ut_params = &unittest_params;
12853
12854         const unsigned int auth_tag_len = tdata->auth_tag.len;
12855         const unsigned int iv_len = tdata->iv.len;
12856         unsigned int aad_len = tdata->aad.len;
12857         unsigned int aad_len_pad = 0;
12858
12859         /* Generate Crypto op data structure */
12860         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12861                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12862         TEST_ASSERT_NOT_NULL(ut_params->op,
12863                 "Failed to allocate symmetric crypto operation struct");
12864
12865         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12866
12867         sym_op->aead.digest.data = digest_mem;
12868
12869         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
12870                         "no room to append digest");
12871
12872         sym_op->aead.digest.phys_addr = digest_phys;
12873
12874         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
12875                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
12876                                 auth_tag_len);
12877                 debug_hexdump(stdout, "digest:",
12878                                 sym_op->aead.digest.data,
12879                                 auth_tag_len);
12880         }
12881
12882         /* Append aad data */
12883         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
12884                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12885                                 uint8_t *, IV_OFFSET);
12886
12887                 /* Copy IV 1 byte after the IV pointer, according to the API */
12888                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
12889
12890                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
12891
12892                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12893                                 ut_params->ibuf, aad_len);
12894                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12895                                 "no room to prepend aad");
12896                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12897                                 ut_params->ibuf);
12898
12899                 memset(sym_op->aead.aad.data, 0, aad_len);
12900                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
12901                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12902
12903                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12904                 debug_hexdump(stdout, "aad:",
12905                                 sym_op->aead.aad.data, aad_len);
12906         } else {
12907                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12908                                 uint8_t *, IV_OFFSET);
12909
12910                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
12911
12912                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
12913
12914                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12915                                 ut_params->ibuf, aad_len_pad);
12916                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12917                                 "no room to prepend aad");
12918                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12919                                 ut_params->ibuf);
12920
12921                 memset(sym_op->aead.aad.data, 0, aad_len);
12922                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12923
12924                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12925                 debug_hexdump(stdout, "aad:",
12926                                 sym_op->aead.aad.data, aad_len);
12927         }
12928
12929         sym_op->aead.data.length = tdata->plaintext.len;
12930         sym_op->aead.data.offset = aad_len_pad;
12931
12932         return 0;
12933 }
12934
12935 #define SGL_MAX_NO      16
12936
12937 static int
12938 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
12939                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
12940 {
12941         struct crypto_testsuite_params *ts_params = &testsuite_params;
12942         struct crypto_unittest_params *ut_params = &unittest_params;
12943         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
12944         int retval;
12945         int to_trn = 0;
12946         int to_trn_tbl[SGL_MAX_NO];
12947         int segs = 1;
12948         unsigned int trn_data = 0;
12949         uint8_t *plaintext, *ciphertext, *auth_tag;
12950         struct rte_cryptodev_info dev_info;
12951
12952         /* Verify the capabilities */
12953         struct rte_cryptodev_sym_capability_idx cap_idx;
12954         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
12955         cap_idx.algo.aead = tdata->algo;
12956         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12957                         &cap_idx) == NULL)
12958                 return TEST_SKIPPED;
12959
12960         /* OOP not supported with CPU crypto */
12961         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12962                 return TEST_SKIPPED;
12963
12964         /* Detailed check for the particular SGL support flag */
12965         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12966         if (!oop) {
12967                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12968                 if (sgl_in && (!(dev_info.feature_flags &
12969                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
12970                         return TEST_SKIPPED;
12971
12972                 uint64_t feat_flags = dev_info.feature_flags;
12973
12974                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12975                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12976                         printf("Device doesn't support RAW data-path APIs.\n");
12977                         return TEST_SKIPPED;
12978                 }
12979         } else {
12980                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12981                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
12982                                 tdata->plaintext.len;
12983                 /* Raw data path API does not support OOP */
12984                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12985                         return TEST_SKIPPED;
12986                 if (sgl_in && !sgl_out) {
12987                         if (!(dev_info.feature_flags &
12988                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
12989                                 return TEST_SKIPPED;
12990                 } else if (!sgl_in && sgl_out) {
12991                         if (!(dev_info.feature_flags &
12992                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
12993                                 return TEST_SKIPPED;
12994                 } else if (sgl_in && sgl_out) {
12995                         if (!(dev_info.feature_flags &
12996                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
12997                                 return TEST_SKIPPED;
12998                 }
12999         }
13000
13001         if (fragsz > tdata->plaintext.len)
13002                 fragsz = tdata->plaintext.len;
13003
13004         uint16_t plaintext_len = fragsz;
13005         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13006
13007         if (fragsz_oop > tdata->plaintext.len)
13008                 frag_size_oop = tdata->plaintext.len;
13009
13010         int ecx = 0;
13011         void *digest_mem = NULL;
13012
13013         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13014
13015         if (tdata->plaintext.len % fragsz != 0) {
13016                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13017                         return 1;
13018         }       else {
13019                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13020                         return 1;
13021         }
13022
13023         /*
13024          * For out-op-place we need to alloc another mbuf
13025          */
13026         if (oop) {
13027                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13028                 rte_pktmbuf_append(ut_params->obuf,
13029                                 frag_size_oop + prepend_len);
13030                 buf_oop = ut_params->obuf;
13031         }
13032
13033         /* Create AEAD session */
13034         retval = create_aead_session(ts_params->valid_devs[0],
13035                         tdata->algo,
13036                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13037                         tdata->key.data, tdata->key.len,
13038                         tdata->aad.len, tdata->auth_tag.len,
13039                         tdata->iv.len);
13040         if (retval < 0)
13041                 return retval;
13042
13043         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13044
13045         /* clear mbuf payload */
13046         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13047                         rte_pktmbuf_tailroom(ut_params->ibuf));
13048
13049         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13050                         plaintext_len);
13051
13052         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13053
13054         trn_data += plaintext_len;
13055
13056         buf = ut_params->ibuf;
13057
13058         /*
13059          * Loop until no more fragments
13060          */
13061
13062         while (trn_data < tdata->plaintext.len) {
13063                 ++segs;
13064                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13065                                 (tdata->plaintext.len - trn_data) : fragsz;
13066
13067                 to_trn_tbl[ecx++] = to_trn;
13068
13069                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13070                 buf = buf->next;
13071
13072                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13073                                 rte_pktmbuf_tailroom(buf));
13074
13075                 /* OOP */
13076                 if (oop && !fragsz_oop) {
13077                         buf_last_oop = buf_oop->next =
13078                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13079                         buf_oop = buf_oop->next;
13080                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13081                                         0, rte_pktmbuf_tailroom(buf_oop));
13082                         rte_pktmbuf_append(buf_oop, to_trn);
13083                 }
13084
13085                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13086                                 to_trn);
13087
13088                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13089                                 to_trn);
13090                 trn_data += to_trn;
13091                 if (trn_data  == tdata->plaintext.len) {
13092                         if (oop) {
13093                                 if (!fragsz_oop)
13094                                         digest_mem = rte_pktmbuf_append(buf_oop,
13095                                                 tdata->auth_tag.len);
13096                         } else
13097                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13098                                         tdata->auth_tag.len);
13099                 }
13100         }
13101
13102         uint64_t digest_phys = 0;
13103
13104         ut_params->ibuf->nb_segs = segs;
13105
13106         segs = 1;
13107         if (fragsz_oop && oop) {
13108                 to_trn = 0;
13109                 ecx = 0;
13110
13111                 if (frag_size_oop == tdata->plaintext.len) {
13112                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
13113                                 tdata->auth_tag.len);
13114
13115                         digest_phys = rte_pktmbuf_iova_offset(
13116                                         ut_params->obuf,
13117                                         tdata->plaintext.len + prepend_len);
13118                 }
13119
13120                 trn_data = frag_size_oop;
13121                 while (trn_data < tdata->plaintext.len) {
13122                         ++segs;
13123                         to_trn =
13124                                 (tdata->plaintext.len - trn_data <
13125                                                 frag_size_oop) ?
13126                                 (tdata->plaintext.len - trn_data) :
13127                                                 frag_size_oop;
13128
13129                         to_trn_tbl[ecx++] = to_trn;
13130
13131                         buf_last_oop = buf_oop->next =
13132                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13133                         buf_oop = buf_oop->next;
13134                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13135                                         0, rte_pktmbuf_tailroom(buf_oop));
13136                         rte_pktmbuf_append(buf_oop, to_trn);
13137
13138                         trn_data += to_trn;
13139
13140                         if (trn_data  == tdata->plaintext.len) {
13141                                 digest_mem = rte_pktmbuf_append(buf_oop,
13142                                         tdata->auth_tag.len);
13143                         }
13144                 }
13145
13146                 ut_params->obuf->nb_segs = segs;
13147         }
13148
13149         /*
13150          * Place digest at the end of the last buffer
13151          */
13152         if (!digest_phys)
13153                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13154         if (oop && buf_last_oop)
13155                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13156
13157         if (!digest_mem && !oop) {
13158                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13159                                 + tdata->auth_tag.len);
13160                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13161                                 tdata->plaintext.len);
13162         }
13163
13164         /* Create AEAD operation */
13165         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13166                         tdata, digest_mem, digest_phys);
13167
13168         if (retval < 0)
13169                 return retval;
13170
13171         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13172
13173         ut_params->op->sym->m_src = ut_params->ibuf;
13174         if (oop)
13175                 ut_params->op->sym->m_dst = ut_params->obuf;
13176
13177         /* Process crypto operation */
13178         if (oop == IN_PLACE &&
13179                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13180                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13181         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13182                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13183                                 ut_params->op, 0, 0, 0, 0);
13184         else
13185                 TEST_ASSERT_NOT_NULL(
13186                         process_crypto_request(ts_params->valid_devs[0],
13187                         ut_params->op), "failed to process sym crypto op");
13188
13189         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13190                         "crypto op processing failed");
13191
13192
13193         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13194                         uint8_t *, prepend_len);
13195         if (oop) {
13196                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13197                                 uint8_t *, prepend_len);
13198         }
13199
13200         if (fragsz_oop)
13201                 fragsz = fragsz_oop;
13202
13203         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13204                         ciphertext,
13205                         tdata->ciphertext.data,
13206                         fragsz,
13207                         "Ciphertext data not as expected");
13208
13209         buf = ut_params->op->sym->m_src->next;
13210         if (oop)
13211                 buf = ut_params->op->sym->m_dst->next;
13212
13213         unsigned int off = fragsz;
13214
13215         ecx = 0;
13216         while (buf) {
13217                 ciphertext = rte_pktmbuf_mtod(buf,
13218                                 uint8_t *);
13219
13220                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13221                                 ciphertext,
13222                                 tdata->ciphertext.data + off,
13223                                 to_trn_tbl[ecx],
13224                                 "Ciphertext data not as expected");
13225
13226                 off += to_trn_tbl[ecx++];
13227                 buf = buf->next;
13228         }
13229
13230         auth_tag = digest_mem;
13231         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13232                         auth_tag,
13233                         tdata->auth_tag.data,
13234                         tdata->auth_tag.len,
13235                         "Generated auth tag not as expected");
13236
13237         return 0;
13238 }
13239
13240 static int
13241 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
13242 {
13243         return test_authenticated_encryption_SGL(
13244                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
13245 }
13246
13247 static int
13248 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
13249 {
13250         return test_authenticated_encryption_SGL(
13251                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
13252 }
13253
13254 static int
13255 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
13256 {
13257         return test_authenticated_encryption_SGL(
13258                         &gcm_test_case_8, OUT_OF_PLACE, 400,
13259                         gcm_test_case_8.plaintext.len);
13260 }
13261
13262 static int
13263 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
13264 {
13265         /* This test is not for OPENSSL PMD */
13266         if (gbl_driver_id == rte_cryptodev_driver_id_get(
13267                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
13268                 return TEST_SKIPPED;
13269
13270         return test_authenticated_encryption_SGL(
13271                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
13272 }
13273
13274 static int
13275 test_authentication_verify_fail_when_data_corrupted(
13276                 struct crypto_testsuite_params *ts_params,
13277                 struct crypto_unittest_params *ut_params,
13278                 const struct test_crypto_vector *reference)
13279 {
13280         return test_authentication_verify_fail_when_data_corruption(
13281                         ts_params, ut_params, reference, 1);
13282 }
13283
13284 static int
13285 test_authentication_verify_fail_when_tag_corrupted(
13286                 struct crypto_testsuite_params *ts_params,
13287                 struct crypto_unittest_params *ut_params,
13288                 const struct test_crypto_vector *reference)
13289 {
13290         return test_authentication_verify_fail_when_data_corruption(
13291                         ts_params, ut_params, reference, 0);
13292 }
13293
13294 static int
13295 test_authentication_verify_GMAC_fail_when_data_corrupted(
13296                 struct crypto_testsuite_params *ts_params,
13297                 struct crypto_unittest_params *ut_params,
13298                 const struct test_crypto_vector *reference)
13299 {
13300         return test_authentication_verify_GMAC_fail_when_corruption(
13301                         ts_params, ut_params, reference, 1);
13302 }
13303
13304 static int
13305 test_authentication_verify_GMAC_fail_when_tag_corrupted(
13306                 struct crypto_testsuite_params *ts_params,
13307                 struct crypto_unittest_params *ut_params,
13308                 const struct test_crypto_vector *reference)
13309 {
13310         return test_authentication_verify_GMAC_fail_when_corruption(
13311                         ts_params, ut_params, reference, 0);
13312 }
13313
13314 static int
13315 test_authenticated_decryption_fail_when_data_corrupted(
13316                 struct crypto_testsuite_params *ts_params,
13317                 struct crypto_unittest_params *ut_params,
13318                 const struct test_crypto_vector *reference)
13319 {
13320         return test_authenticated_decryption_fail_when_corruption(
13321                         ts_params, ut_params, reference, 1);
13322 }
13323
13324 static int
13325 test_authenticated_decryption_fail_when_tag_corrupted(
13326                 struct crypto_testsuite_params *ts_params,
13327                 struct crypto_unittest_params *ut_params,
13328                 const struct test_crypto_vector *reference)
13329 {
13330         return test_authenticated_decryption_fail_when_corruption(
13331                         ts_params, ut_params, reference, 0);
13332 }
13333
13334 static int
13335 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
13336 {
13337         return test_authentication_verify_fail_when_data_corrupted(
13338                         &testsuite_params, &unittest_params,
13339                         &hmac_sha1_test_crypto_vector);
13340 }
13341
13342 static int
13343 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
13344 {
13345         return test_authentication_verify_fail_when_tag_corrupted(
13346                         &testsuite_params, &unittest_params,
13347                         &hmac_sha1_test_crypto_vector);
13348 }
13349
13350 static int
13351 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
13352 {
13353         return test_authentication_verify_GMAC_fail_when_data_corrupted(
13354                         &testsuite_params, &unittest_params,
13355                         &aes128_gmac_test_vector);
13356 }
13357
13358 static int
13359 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
13360 {
13361         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
13362                         &testsuite_params, &unittest_params,
13363                         &aes128_gmac_test_vector);
13364 }
13365
13366 static int
13367 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
13368 {
13369         return test_authenticated_decryption_fail_when_data_corrupted(
13370                         &testsuite_params,
13371                         &unittest_params,
13372                         &aes128cbc_hmac_sha1_test_vector);
13373 }
13374
13375 static int
13376 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
13377 {
13378         return test_authenticated_decryption_fail_when_tag_corrupted(
13379                         &testsuite_params,
13380                         &unittest_params,
13381                         &aes128cbc_hmac_sha1_test_vector);
13382 }
13383
13384 static int
13385 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13386 {
13387         return test_authenticated_encrypt_with_esn(
13388                         &testsuite_params,
13389                         &unittest_params,
13390                         &aes128cbc_hmac_sha1_aad_test_vector);
13391 }
13392
13393 static int
13394 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13395 {
13396         return test_authenticated_decrypt_with_esn(
13397                         &testsuite_params,
13398                         &unittest_params,
13399                         &aes128cbc_hmac_sha1_aad_test_vector);
13400 }
13401
13402 static int
13403 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
13404 {
13405         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
13406 }
13407
13408 static int
13409 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
13410 {
13411         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
13412 }
13413
13414 #ifdef RTE_CRYPTO_SCHEDULER
13415
13416 /* global AESNI worker IDs for the scheduler test */
13417 uint8_t aesni_ids[2];
13418
13419 static int
13420 scheduler_testsuite_setup(void)
13421 {
13422         uint32_t i = 0;
13423         int32_t nb_devs, ret;
13424         char vdev_args[VDEV_ARGS_SIZE] = {""};
13425         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
13426                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
13427         uint16_t worker_core_count = 0;
13428         uint16_t socket_id = 0;
13429
13430         if (gbl_driver_id == rte_cryptodev_driver_id_get(
13431                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
13432
13433                 /* Identify the Worker Cores
13434                  * Use 2 worker cores for the device args
13435                  */
13436                 RTE_LCORE_FOREACH_WORKER(i) {
13437                         if (worker_core_count > 1)
13438                                 break;
13439                         snprintf(vdev_args, sizeof(vdev_args),
13440                                         "%s%d", temp_str, i);
13441                         strcpy(temp_str, vdev_args);
13442                         strlcat(temp_str, ";", sizeof(temp_str));
13443                         worker_core_count++;
13444                         socket_id = rte_lcore_to_socket_id(i);
13445                 }
13446                 if (worker_core_count != 2) {
13447                         RTE_LOG(ERR, USER1,
13448                                 "Cryptodev scheduler test require at least "
13449                                 "two worker cores to run. "
13450                                 "Please use the correct coremask.\n");
13451                         return TEST_FAILED;
13452                 }
13453                 strcpy(temp_str, vdev_args);
13454                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
13455                                 temp_str, socket_id);
13456                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
13457                 nb_devs = rte_cryptodev_device_count_by_driver(
13458                                 rte_cryptodev_driver_id_get(
13459                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
13460                 if (nb_devs < 1) {
13461                         ret = rte_vdev_init(
13462                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
13463                                         vdev_args);
13464                         TEST_ASSERT(ret == 0,
13465                                 "Failed to create instance %u of pmd : %s",
13466                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13467                 }
13468         }
13469         return testsuite_setup();
13470 }
13471
13472 static int
13473 test_scheduler_attach_worker_op(void)
13474 {
13475         struct crypto_testsuite_params *ts_params = &testsuite_params;
13476         uint8_t sched_id = ts_params->valid_devs[0];
13477         uint32_t i, nb_devs_attached = 0;
13478         int ret;
13479         char vdev_name[32];
13480         unsigned int count = rte_cryptodev_count();
13481
13482         /* create 2 AESNI_MB vdevs on top of existing devices */
13483         for (i = count; i < count + 2; i++) {
13484                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
13485                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
13486                                 i);
13487                 ret = rte_vdev_init(vdev_name, NULL);
13488
13489                 TEST_ASSERT(ret == 0,
13490                         "Failed to create instance %u of"
13491                         " pmd : %s",
13492                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13493
13494                 if (ret < 0) {
13495                         RTE_LOG(ERR, USER1,
13496                                 "Failed to create 2 AESNI MB PMDs.\n");
13497                         return TEST_SKIPPED;
13498                 }
13499         }
13500
13501         /* attach 2 AESNI_MB cdevs */
13502         for (i = count; i < count + 2; i++) {
13503                 struct rte_cryptodev_info info;
13504                 unsigned int session_size;
13505
13506                 rte_cryptodev_info_get(i, &info);
13507                 if (info.driver_id != rte_cryptodev_driver_id_get(
13508                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
13509                         continue;
13510
13511                 session_size = rte_cryptodev_sym_get_private_session_size(i);
13512                 /*
13513                  * Create the session mempool again, since now there are new devices
13514                  * to use the mempool.
13515                  */
13516                 if (ts_params->session_mpool) {
13517                         rte_mempool_free(ts_params->session_mpool);
13518                         ts_params->session_mpool = NULL;
13519                 }
13520                 if (ts_params->session_priv_mpool) {
13521                         rte_mempool_free(ts_params->session_priv_mpool);
13522                         ts_params->session_priv_mpool = NULL;
13523                 }
13524
13525                 if (info.sym.max_nb_sessions != 0 &&
13526                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
13527                         RTE_LOG(ERR, USER1,
13528                                         "Device does not support "
13529                                         "at least %u sessions\n",
13530                                         MAX_NB_SESSIONS);
13531                         return TEST_FAILED;
13532                 }
13533                 /*
13534                  * Create mempool with maximum number of sessions,
13535                  * to include the session headers
13536                  */
13537                 if (ts_params->session_mpool == NULL) {
13538                         ts_params->session_mpool =
13539                                 rte_cryptodev_sym_session_pool_create(
13540                                                 "test_sess_mp",
13541                                                 MAX_NB_SESSIONS, 0, 0, 0,
13542                                                 SOCKET_ID_ANY);
13543                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
13544                                         "session mempool allocation failed");
13545                 }
13546
13547                 /*
13548                  * Create mempool with maximum number of sessions,
13549                  * to include device specific session private data
13550                  */
13551                 if (ts_params->session_priv_mpool == NULL) {
13552                         ts_params->session_priv_mpool = rte_mempool_create(
13553                                         "test_sess_mp_priv",
13554                                         MAX_NB_SESSIONS,
13555                                         session_size,
13556                                         0, 0, NULL, NULL, NULL,
13557                                         NULL, SOCKET_ID_ANY,
13558                                         0);
13559
13560                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
13561                                         "session mempool allocation failed");
13562                 }
13563
13564                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
13565                 ts_params->qp_conf.mp_session_private =
13566                                 ts_params->session_priv_mpool;
13567
13568                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
13569                                 (uint8_t)i);
13570
13571                 TEST_ASSERT(ret == 0,
13572                         "Failed to attach device %u of pmd : %s", i,
13573                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13574
13575                 aesni_ids[nb_devs_attached] = (uint8_t)i;
13576
13577                 nb_devs_attached++;
13578         }
13579
13580         return 0;
13581 }
13582
13583 static int
13584 test_scheduler_detach_worker_op(void)
13585 {
13586         struct crypto_testsuite_params *ts_params = &testsuite_params;
13587         uint8_t sched_id = ts_params->valid_devs[0];
13588         uint32_t i;
13589         int ret;
13590
13591         for (i = 0; i < 2; i++) {
13592                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
13593                                 aesni_ids[i]);
13594                 TEST_ASSERT(ret == 0,
13595                         "Failed to detach device %u", aesni_ids[i]);
13596         }
13597
13598         return 0;
13599 }
13600
13601 static int
13602 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
13603 {
13604         struct crypto_testsuite_params *ts_params = &testsuite_params;
13605         uint8_t sched_id = ts_params->valid_devs[0];
13606         /* set mode */
13607         return rte_cryptodev_scheduler_mode_set(sched_id,
13608                 scheduler_mode);
13609 }
13610
13611 static int
13612 test_scheduler_mode_roundrobin_op(void)
13613 {
13614         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
13615                         0, "Failed to set roundrobin mode");
13616         return 0;
13617
13618 }
13619
13620 static int
13621 test_scheduler_mode_multicore_op(void)
13622 {
13623         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
13624                         0, "Failed to set multicore mode");
13625
13626         return 0;
13627 }
13628
13629 static int
13630 test_scheduler_mode_failover_op(void)
13631 {
13632         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
13633                         0, "Failed to set failover mode");
13634
13635         return 0;
13636 }
13637
13638 static int
13639 test_scheduler_mode_pkt_size_distr_op(void)
13640 {
13641         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
13642                         0, "Failed to set pktsize mode");
13643
13644         return 0;
13645 }
13646
13647 static int
13648 scheduler_multicore_testsuite_setup(void)
13649 {
13650         if (test_scheduler_attach_worker_op() < 0)
13651                 return TEST_SKIPPED;
13652         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
13653                 return TEST_SKIPPED;
13654         return 0;
13655 }
13656
13657 static int
13658 scheduler_roundrobin_testsuite_setup(void)
13659 {
13660         if (test_scheduler_attach_worker_op() < 0)
13661                 return TEST_SKIPPED;
13662         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
13663                 return TEST_SKIPPED;
13664         return 0;
13665 }
13666
13667 static int
13668 scheduler_failover_testsuite_setup(void)
13669 {
13670         if (test_scheduler_attach_worker_op() < 0)
13671                 return TEST_SKIPPED;
13672         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
13673                 return TEST_SKIPPED;
13674         return 0;
13675 }
13676
13677 static int
13678 scheduler_pkt_size_distr_testsuite_setup(void)
13679 {
13680         if (test_scheduler_attach_worker_op() < 0)
13681                 return TEST_SKIPPED;
13682         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
13683                 return TEST_SKIPPED;
13684         return 0;
13685 }
13686
13687 static void
13688 scheduler_mode_testsuite_teardown(void)
13689 {
13690         test_scheduler_detach_worker_op();
13691 }
13692
13693 #endif /* RTE_CRYPTO_SCHEDULER */
13694
13695 static struct unit_test_suite end_testsuite = {
13696         .suite_name = NULL,
13697         .setup = NULL,
13698         .teardown = NULL,
13699         .unit_test_suites = NULL
13700 };
13701
13702 #ifdef RTE_LIB_SECURITY
13703 static struct unit_test_suite pdcp_proto_testsuite  = {
13704         .suite_name = "PDCP Proto Unit Test Suite",
13705         .setup = pdcp_proto_testsuite_setup,
13706         .unit_test_cases = {
13707                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13708                         test_PDCP_PROTO_all),
13709                 TEST_CASES_END() /**< NULL terminate unit test array */
13710         }
13711 };
13712
13713 static struct unit_test_suite docsis_proto_testsuite  = {
13714         .suite_name = "Docsis Proto Unit Test Suite",
13715         .setup = docsis_proto_testsuite_setup,
13716         .unit_test_cases = {
13717                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13718                         test_DOCSIS_PROTO_all),
13719                 TEST_CASES_END() /**< NULL terminate unit test array */
13720         }
13721 };
13722 #endif
13723
13724 static struct unit_test_suite cryptodev_gen_testsuite  = {
13725         .suite_name = "Crypto General Unit Test Suite",
13726         .setup = crypto_gen_testsuite_setup,
13727         .unit_test_cases = {
13728                 TEST_CASE_ST(ut_setup, ut_teardown,
13729                                 test_device_configure_invalid_dev_id),
13730                 TEST_CASE_ST(ut_setup, ut_teardown,
13731                                 test_queue_pair_descriptor_setup),
13732                 TEST_CASE_ST(ut_setup, ut_teardown,
13733                                 test_device_configure_invalid_queue_pair_ids),
13734                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
13735                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
13736                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
13737                 TEST_CASES_END() /**< NULL terminate unit test array */
13738         }
13739 };
13740
13741 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
13742         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
13743         .setup = negative_hmac_sha1_testsuite_setup,
13744         .unit_test_cases = {
13745                 /** Negative tests */
13746                 TEST_CASE_ST(ut_setup, ut_teardown,
13747                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13748                 TEST_CASE_ST(ut_setup, ut_teardown,
13749                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13750                 TEST_CASE_ST(ut_setup, ut_teardown,
13751                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13752                 TEST_CASE_ST(ut_setup, ut_teardown,
13753                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13754
13755                 TEST_CASES_END() /**< NULL terminate unit test array */
13756         }
13757 };
13758
13759 static struct unit_test_suite cryptodev_multi_session_testsuite = {
13760         .suite_name = "Multi Session Unit Test Suite",
13761         .setup = multi_session_testsuite_setup,
13762         .unit_test_cases = {
13763                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13764                 TEST_CASE_ST(ut_setup, ut_teardown,
13765                                 test_multi_session_random_usage),
13766
13767                 TEST_CASES_END() /**< NULL terminate unit test array */
13768         }
13769 };
13770
13771 static struct unit_test_suite cryptodev_null_testsuite  = {
13772         .suite_name = "NULL Test Suite",
13773         .setup = null_testsuite_setup,
13774         .unit_test_cases = {
13775                 TEST_CASE_ST(ut_setup, ut_teardown,
13776                         test_null_invalid_operation),
13777                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
13778                 TEST_CASES_END()
13779         }
13780 };
13781
13782 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
13783         .suite_name = "AES CCM Authenticated Test Suite",
13784         .setup = aes_ccm_auth_testsuite_setup,
13785         .unit_test_cases = {
13786                 /** AES CCM Authenticated Encryption 128 bits key*/
13787                 TEST_CASE_ST(ut_setup, ut_teardown,
13788                         test_AES_CCM_authenticated_encryption_test_case_128_1),
13789                 TEST_CASE_ST(ut_setup, ut_teardown,
13790                         test_AES_CCM_authenticated_encryption_test_case_128_2),
13791                 TEST_CASE_ST(ut_setup, ut_teardown,
13792                         test_AES_CCM_authenticated_encryption_test_case_128_3),
13793
13794                 /** AES CCM Authenticated Decryption 128 bits key*/
13795                 TEST_CASE_ST(ut_setup, ut_teardown,
13796                         test_AES_CCM_authenticated_decryption_test_case_128_1),
13797                 TEST_CASE_ST(ut_setup, ut_teardown,
13798                         test_AES_CCM_authenticated_decryption_test_case_128_2),
13799                 TEST_CASE_ST(ut_setup, ut_teardown,
13800                         test_AES_CCM_authenticated_decryption_test_case_128_3),
13801
13802                 /** AES CCM Authenticated Encryption 192 bits key */
13803                 TEST_CASE_ST(ut_setup, ut_teardown,
13804                         test_AES_CCM_authenticated_encryption_test_case_192_1),
13805                 TEST_CASE_ST(ut_setup, ut_teardown,
13806                         test_AES_CCM_authenticated_encryption_test_case_192_2),
13807                 TEST_CASE_ST(ut_setup, ut_teardown,
13808                         test_AES_CCM_authenticated_encryption_test_case_192_3),
13809
13810                 /** AES CCM Authenticated Decryption 192 bits key*/
13811                 TEST_CASE_ST(ut_setup, ut_teardown,
13812                         test_AES_CCM_authenticated_decryption_test_case_192_1),
13813                 TEST_CASE_ST(ut_setup, ut_teardown,
13814                         test_AES_CCM_authenticated_decryption_test_case_192_2),
13815                 TEST_CASE_ST(ut_setup, ut_teardown,
13816                         test_AES_CCM_authenticated_decryption_test_case_192_3),
13817
13818                 /** AES CCM Authenticated Encryption 256 bits key */
13819                 TEST_CASE_ST(ut_setup, ut_teardown,
13820                         test_AES_CCM_authenticated_encryption_test_case_256_1),
13821                 TEST_CASE_ST(ut_setup, ut_teardown,
13822                         test_AES_CCM_authenticated_encryption_test_case_256_2),
13823                 TEST_CASE_ST(ut_setup, ut_teardown,
13824                         test_AES_CCM_authenticated_encryption_test_case_256_3),
13825
13826                 /** AES CCM Authenticated Decryption 256 bits key*/
13827                 TEST_CASE_ST(ut_setup, ut_teardown,
13828                         test_AES_CCM_authenticated_decryption_test_case_256_1),
13829                 TEST_CASE_ST(ut_setup, ut_teardown,
13830                         test_AES_CCM_authenticated_decryption_test_case_256_2),
13831                 TEST_CASE_ST(ut_setup, ut_teardown,
13832                         test_AES_CCM_authenticated_decryption_test_case_256_3),
13833                 TEST_CASES_END()
13834         }
13835 };
13836
13837 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
13838         .suite_name = "AES GCM Authenticated Test Suite",
13839         .setup = aes_gcm_auth_testsuite_setup,
13840         .unit_test_cases = {
13841                 /** AES GCM Authenticated Encryption */
13842                 TEST_CASE_ST(ut_setup, ut_teardown,
13843                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13844                 TEST_CASE_ST(ut_setup, ut_teardown,
13845                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13846                 TEST_CASE_ST(ut_setup, ut_teardown,
13847                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13848                 TEST_CASE_ST(ut_setup, ut_teardown,
13849                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13850                 TEST_CASE_ST(ut_setup, ut_teardown,
13851                         test_AES_GCM_authenticated_encryption_test_case_1),
13852                 TEST_CASE_ST(ut_setup, ut_teardown,
13853                         test_AES_GCM_authenticated_encryption_test_case_2),
13854                 TEST_CASE_ST(ut_setup, ut_teardown,
13855                         test_AES_GCM_authenticated_encryption_test_case_3),
13856                 TEST_CASE_ST(ut_setup, ut_teardown,
13857                         test_AES_GCM_authenticated_encryption_test_case_4),
13858                 TEST_CASE_ST(ut_setup, ut_teardown,
13859                         test_AES_GCM_authenticated_encryption_test_case_5),
13860                 TEST_CASE_ST(ut_setup, ut_teardown,
13861                         test_AES_GCM_authenticated_encryption_test_case_6),
13862                 TEST_CASE_ST(ut_setup, ut_teardown,
13863                         test_AES_GCM_authenticated_encryption_test_case_7),
13864                 TEST_CASE_ST(ut_setup, ut_teardown,
13865                         test_AES_GCM_authenticated_encryption_test_case_8),
13866                 TEST_CASE_ST(ut_setup, ut_teardown,
13867                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
13868
13869                 /** AES GCM Authenticated Decryption */
13870                 TEST_CASE_ST(ut_setup, ut_teardown,
13871                         test_AES_GCM_authenticated_decryption_test_case_1),
13872                 TEST_CASE_ST(ut_setup, ut_teardown,
13873                         test_AES_GCM_authenticated_decryption_test_case_2),
13874                 TEST_CASE_ST(ut_setup, ut_teardown,
13875                         test_AES_GCM_authenticated_decryption_test_case_3),
13876                 TEST_CASE_ST(ut_setup, ut_teardown,
13877                         test_AES_GCM_authenticated_decryption_test_case_4),
13878                 TEST_CASE_ST(ut_setup, ut_teardown,
13879                         test_AES_GCM_authenticated_decryption_test_case_5),
13880                 TEST_CASE_ST(ut_setup, ut_teardown,
13881                         test_AES_GCM_authenticated_decryption_test_case_6),
13882                 TEST_CASE_ST(ut_setup, ut_teardown,
13883                         test_AES_GCM_authenticated_decryption_test_case_7),
13884                 TEST_CASE_ST(ut_setup, ut_teardown,
13885                         test_AES_GCM_authenticated_decryption_test_case_8),
13886                 TEST_CASE_ST(ut_setup, ut_teardown,
13887                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
13888
13889                 /** AES GCM Authenticated Encryption 192 bits key */
13890                 TEST_CASE_ST(ut_setup, ut_teardown,
13891                         test_AES_GCM_auth_encryption_test_case_192_1),
13892                 TEST_CASE_ST(ut_setup, ut_teardown,
13893                         test_AES_GCM_auth_encryption_test_case_192_2),
13894                 TEST_CASE_ST(ut_setup, ut_teardown,
13895                         test_AES_GCM_auth_encryption_test_case_192_3),
13896                 TEST_CASE_ST(ut_setup, ut_teardown,
13897                         test_AES_GCM_auth_encryption_test_case_192_4),
13898                 TEST_CASE_ST(ut_setup, ut_teardown,
13899                         test_AES_GCM_auth_encryption_test_case_192_5),
13900                 TEST_CASE_ST(ut_setup, ut_teardown,
13901                         test_AES_GCM_auth_encryption_test_case_192_6),
13902                 TEST_CASE_ST(ut_setup, ut_teardown,
13903                         test_AES_GCM_auth_encryption_test_case_192_7),
13904
13905                 /** AES GCM Authenticated Decryption 192 bits key */
13906                 TEST_CASE_ST(ut_setup, ut_teardown,
13907                         test_AES_GCM_auth_decryption_test_case_192_1),
13908                 TEST_CASE_ST(ut_setup, ut_teardown,
13909                         test_AES_GCM_auth_decryption_test_case_192_2),
13910                 TEST_CASE_ST(ut_setup, ut_teardown,
13911                         test_AES_GCM_auth_decryption_test_case_192_3),
13912                 TEST_CASE_ST(ut_setup, ut_teardown,
13913                         test_AES_GCM_auth_decryption_test_case_192_4),
13914                 TEST_CASE_ST(ut_setup, ut_teardown,
13915                         test_AES_GCM_auth_decryption_test_case_192_5),
13916                 TEST_CASE_ST(ut_setup, ut_teardown,
13917                         test_AES_GCM_auth_decryption_test_case_192_6),
13918                 TEST_CASE_ST(ut_setup, ut_teardown,
13919                         test_AES_GCM_auth_decryption_test_case_192_7),
13920
13921                 /** AES GCM Authenticated Encryption 256 bits key */
13922                 TEST_CASE_ST(ut_setup, ut_teardown,
13923                         test_AES_GCM_auth_encryption_test_case_256_1),
13924                 TEST_CASE_ST(ut_setup, ut_teardown,
13925                         test_AES_GCM_auth_encryption_test_case_256_2),
13926                 TEST_CASE_ST(ut_setup, ut_teardown,
13927                         test_AES_GCM_auth_encryption_test_case_256_3),
13928                 TEST_CASE_ST(ut_setup, ut_teardown,
13929                         test_AES_GCM_auth_encryption_test_case_256_4),
13930                 TEST_CASE_ST(ut_setup, ut_teardown,
13931                         test_AES_GCM_auth_encryption_test_case_256_5),
13932                 TEST_CASE_ST(ut_setup, ut_teardown,
13933                         test_AES_GCM_auth_encryption_test_case_256_6),
13934                 TEST_CASE_ST(ut_setup, ut_teardown,
13935                         test_AES_GCM_auth_encryption_test_case_256_7),
13936
13937                 /** AES GCM Authenticated Decryption 256 bits key */
13938                 TEST_CASE_ST(ut_setup, ut_teardown,
13939                         test_AES_GCM_auth_decryption_test_case_256_1),
13940                 TEST_CASE_ST(ut_setup, ut_teardown,
13941                         test_AES_GCM_auth_decryption_test_case_256_2),
13942                 TEST_CASE_ST(ut_setup, ut_teardown,
13943                         test_AES_GCM_auth_decryption_test_case_256_3),
13944                 TEST_CASE_ST(ut_setup, ut_teardown,
13945                         test_AES_GCM_auth_decryption_test_case_256_4),
13946                 TEST_CASE_ST(ut_setup, ut_teardown,
13947                         test_AES_GCM_auth_decryption_test_case_256_5),
13948                 TEST_CASE_ST(ut_setup, ut_teardown,
13949                         test_AES_GCM_auth_decryption_test_case_256_6),
13950                 TEST_CASE_ST(ut_setup, ut_teardown,
13951                         test_AES_GCM_auth_decryption_test_case_256_7),
13952
13953                 /** AES GCM Authenticated Encryption big aad size */
13954                 TEST_CASE_ST(ut_setup, ut_teardown,
13955                         test_AES_GCM_auth_encryption_test_case_aad_1),
13956                 TEST_CASE_ST(ut_setup, ut_teardown,
13957                         test_AES_GCM_auth_encryption_test_case_aad_2),
13958
13959                 /** AES GCM Authenticated Decryption big aad size */
13960                 TEST_CASE_ST(ut_setup, ut_teardown,
13961                         test_AES_GCM_auth_decryption_test_case_aad_1),
13962                 TEST_CASE_ST(ut_setup, ut_teardown,
13963                         test_AES_GCM_auth_decryption_test_case_aad_2),
13964
13965                 /** Out of place tests */
13966                 TEST_CASE_ST(ut_setup, ut_teardown,
13967                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13968                 TEST_CASE_ST(ut_setup, ut_teardown,
13969                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13970
13971                 /** Session-less tests */
13972                 TEST_CASE_ST(ut_setup, ut_teardown,
13973                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13974                 TEST_CASE_ST(ut_setup, ut_teardown,
13975                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13976
13977                 TEST_CASES_END()
13978         }
13979 };
13980
13981 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
13982         .suite_name = "AES GMAC Authentication Test Suite",
13983         .setup = aes_gmac_auth_testsuite_setup,
13984         .unit_test_cases = {
13985                 TEST_CASE_ST(ut_setup, ut_teardown,
13986                         test_AES_GMAC_authentication_test_case_1),
13987                 TEST_CASE_ST(ut_setup, ut_teardown,
13988                         test_AES_GMAC_authentication_verify_test_case_1),
13989                 TEST_CASE_ST(ut_setup, ut_teardown,
13990                         test_AES_GMAC_authentication_test_case_2),
13991                 TEST_CASE_ST(ut_setup, ut_teardown,
13992                         test_AES_GMAC_authentication_verify_test_case_2),
13993                 TEST_CASE_ST(ut_setup, ut_teardown,
13994                         test_AES_GMAC_authentication_test_case_3),
13995                 TEST_CASE_ST(ut_setup, ut_teardown,
13996                         test_AES_GMAC_authentication_verify_test_case_3),
13997                 TEST_CASE_ST(ut_setup, ut_teardown,
13998                         test_AES_GMAC_authentication_test_case_4),
13999                 TEST_CASE_ST(ut_setup, ut_teardown,
14000                         test_AES_GMAC_authentication_verify_test_case_4),
14001                 TEST_CASE_ST(ut_setup, ut_teardown,
14002                         test_AES_GMAC_authentication_SGL_40B),
14003                 TEST_CASE_ST(ut_setup, ut_teardown,
14004                         test_AES_GMAC_authentication_SGL_80B),
14005                 TEST_CASE_ST(ut_setup, ut_teardown,
14006                         test_AES_GMAC_authentication_SGL_2048B),
14007                 TEST_CASE_ST(ut_setup, ut_teardown,
14008                         test_AES_GMAC_authentication_SGL_2047B),
14009
14010                 TEST_CASES_END()
14011         }
14012 };
14013
14014 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
14015         .suite_name = "Chacha20-Poly1305 Test Suite",
14016         .setup = chacha20_poly1305_testsuite_setup,
14017         .unit_test_cases = {
14018                 TEST_CASE_ST(ut_setup, ut_teardown,
14019                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
14020                 TEST_CASE_ST(ut_setup, ut_teardown,
14021                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
14022                 TEST_CASES_END()
14023         }
14024 };
14025
14026 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
14027         .suite_name = "SNOW 3G Test Suite",
14028         .setup = snow3g_testsuite_setup,
14029         .unit_test_cases = {
14030                 /** SNOW 3G encrypt only (UEA2) */
14031                 TEST_CASE_ST(ut_setup, ut_teardown,
14032                         test_snow3g_encryption_test_case_1),
14033                 TEST_CASE_ST(ut_setup, ut_teardown,
14034                         test_snow3g_encryption_test_case_2),
14035                 TEST_CASE_ST(ut_setup, ut_teardown,
14036                         test_snow3g_encryption_test_case_3),
14037                 TEST_CASE_ST(ut_setup, ut_teardown,
14038                         test_snow3g_encryption_test_case_4),
14039                 TEST_CASE_ST(ut_setup, ut_teardown,
14040                         test_snow3g_encryption_test_case_5),
14041
14042                 TEST_CASE_ST(ut_setup, ut_teardown,
14043                         test_snow3g_encryption_test_case_1_oop),
14044                 TEST_CASE_ST(ut_setup, ut_teardown,
14045                         test_snow3g_encryption_test_case_1_oop_sgl),
14046                 TEST_CASE_ST(ut_setup, ut_teardown,
14047                         test_snow3g_encryption_test_case_1_offset_oop),
14048                 TEST_CASE_ST(ut_setup, ut_teardown,
14049                         test_snow3g_decryption_test_case_1_oop),
14050
14051                 /** SNOW 3G generate auth, then encrypt (UEA2) */
14052                 TEST_CASE_ST(ut_setup, ut_teardown,
14053                         test_snow3g_auth_cipher_test_case_1),
14054                 TEST_CASE_ST(ut_setup, ut_teardown,
14055                         test_snow3g_auth_cipher_test_case_2),
14056                 TEST_CASE_ST(ut_setup, ut_teardown,
14057                         test_snow3g_auth_cipher_test_case_2_oop),
14058                 TEST_CASE_ST(ut_setup, ut_teardown,
14059                         test_snow3g_auth_cipher_part_digest_enc),
14060                 TEST_CASE_ST(ut_setup, ut_teardown,
14061                         test_snow3g_auth_cipher_part_digest_enc_oop),
14062                 TEST_CASE_ST(ut_setup, ut_teardown,
14063                         test_snow3g_auth_cipher_test_case_3_sgl),
14064                 TEST_CASE_ST(ut_setup, ut_teardown,
14065                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
14066                 TEST_CASE_ST(ut_setup, ut_teardown,
14067                         test_snow3g_auth_cipher_part_digest_enc_sgl),
14068                 TEST_CASE_ST(ut_setup, ut_teardown,
14069                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
14070
14071                 /** SNOW 3G decrypt (UEA2), then verify auth */
14072                 TEST_CASE_ST(ut_setup, ut_teardown,
14073                         test_snow3g_auth_cipher_verify_test_case_1),
14074                 TEST_CASE_ST(ut_setup, ut_teardown,
14075                         test_snow3g_auth_cipher_verify_test_case_2),
14076                 TEST_CASE_ST(ut_setup, ut_teardown,
14077                         test_snow3g_auth_cipher_verify_test_case_2_oop),
14078                 TEST_CASE_ST(ut_setup, ut_teardown,
14079                         test_snow3g_auth_cipher_verify_part_digest_enc),
14080                 TEST_CASE_ST(ut_setup, ut_teardown,
14081                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
14082                 TEST_CASE_ST(ut_setup, ut_teardown,
14083                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
14084                 TEST_CASE_ST(ut_setup, ut_teardown,
14085                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
14086                 TEST_CASE_ST(ut_setup, ut_teardown,
14087                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
14088                 TEST_CASE_ST(ut_setup, ut_teardown,
14089                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
14090
14091                 /** SNOW 3G decrypt only (UEA2) */
14092                 TEST_CASE_ST(ut_setup, ut_teardown,
14093                         test_snow3g_decryption_test_case_1),
14094                 TEST_CASE_ST(ut_setup, ut_teardown,
14095                         test_snow3g_decryption_test_case_2),
14096                 TEST_CASE_ST(ut_setup, ut_teardown,
14097                         test_snow3g_decryption_test_case_3),
14098                 TEST_CASE_ST(ut_setup, ut_teardown,
14099                         test_snow3g_decryption_test_case_4),
14100                 TEST_CASE_ST(ut_setup, ut_teardown,
14101                         test_snow3g_decryption_test_case_5),
14102                 TEST_CASE_ST(ut_setup, ut_teardown,
14103                         test_snow3g_decryption_with_digest_test_case_1),
14104                 TEST_CASE_ST(ut_setup, ut_teardown,
14105                         test_snow3g_hash_generate_test_case_1),
14106                 TEST_CASE_ST(ut_setup, ut_teardown,
14107                         test_snow3g_hash_generate_test_case_2),
14108                 TEST_CASE_ST(ut_setup, ut_teardown,
14109                         test_snow3g_hash_generate_test_case_3),
14110
14111                 /* Tests with buffers which length is not byte-aligned */
14112                 TEST_CASE_ST(ut_setup, ut_teardown,
14113                         test_snow3g_hash_generate_test_case_4),
14114                 TEST_CASE_ST(ut_setup, ut_teardown,
14115                         test_snow3g_hash_generate_test_case_5),
14116                 TEST_CASE_ST(ut_setup, ut_teardown,
14117                         test_snow3g_hash_generate_test_case_6),
14118                 TEST_CASE_ST(ut_setup, ut_teardown,
14119                         test_snow3g_hash_verify_test_case_1),
14120                 TEST_CASE_ST(ut_setup, ut_teardown,
14121                         test_snow3g_hash_verify_test_case_2),
14122                 TEST_CASE_ST(ut_setup, ut_teardown,
14123                         test_snow3g_hash_verify_test_case_3),
14124
14125                 /* Tests with buffers which length is not byte-aligned */
14126                 TEST_CASE_ST(ut_setup, ut_teardown,
14127                         test_snow3g_hash_verify_test_case_4),
14128                 TEST_CASE_ST(ut_setup, ut_teardown,
14129                         test_snow3g_hash_verify_test_case_5),
14130                 TEST_CASE_ST(ut_setup, ut_teardown,
14131                         test_snow3g_hash_verify_test_case_6),
14132                 TEST_CASE_ST(ut_setup, ut_teardown,
14133                         test_snow3g_cipher_auth_test_case_1),
14134                 TEST_CASE_ST(ut_setup, ut_teardown,
14135                         test_snow3g_auth_cipher_with_digest_test_case_1),
14136                 TEST_CASES_END()
14137         }
14138 };
14139
14140 static struct unit_test_suite cryptodev_zuc_testsuite  = {
14141         .suite_name = "ZUC Test Suite",
14142         .setup = zuc_testsuite_setup,
14143         .unit_test_cases = {
14144                 /** ZUC encrypt only (EEA3) */
14145                 TEST_CASE_ST(ut_setup, ut_teardown,
14146                         test_zuc_encryption_test_case_1),
14147                 TEST_CASE_ST(ut_setup, ut_teardown,
14148                         test_zuc_encryption_test_case_2),
14149                 TEST_CASE_ST(ut_setup, ut_teardown,
14150                         test_zuc_encryption_test_case_3),
14151                 TEST_CASE_ST(ut_setup, ut_teardown,
14152                         test_zuc_encryption_test_case_4),
14153                 TEST_CASE_ST(ut_setup, ut_teardown,
14154                         test_zuc_encryption_test_case_5),
14155                 TEST_CASE_ST(ut_setup, ut_teardown,
14156                         test_zuc_encryption_test_case_6_sgl),
14157
14158                 /** ZUC authenticate (EIA3) */
14159                 TEST_CASE_ST(ut_setup, ut_teardown,
14160                         test_zuc_hash_generate_test_case_1),
14161                 TEST_CASE_ST(ut_setup, ut_teardown,
14162                         test_zuc_hash_generate_test_case_2),
14163                 TEST_CASE_ST(ut_setup, ut_teardown,
14164                         test_zuc_hash_generate_test_case_3),
14165                 TEST_CASE_ST(ut_setup, ut_teardown,
14166                         test_zuc_hash_generate_test_case_4),
14167                 TEST_CASE_ST(ut_setup, ut_teardown,
14168                         test_zuc_hash_generate_test_case_5),
14169                 TEST_CASE_ST(ut_setup, ut_teardown,
14170                         test_zuc_hash_generate_test_case_6),
14171                 TEST_CASE_ST(ut_setup, ut_teardown,
14172                         test_zuc_hash_generate_test_case_7),
14173                 TEST_CASE_ST(ut_setup, ut_teardown,
14174                         test_zuc_hash_generate_test_case_8),
14175
14176                 /** ZUC alg-chain (EEA3/EIA3) */
14177                 TEST_CASE_ST(ut_setup, ut_teardown,
14178                         test_zuc_cipher_auth_test_case_1),
14179                 TEST_CASE_ST(ut_setup, ut_teardown,
14180                         test_zuc_cipher_auth_test_case_2),
14181
14182                 /** ZUC generate auth, then encrypt (EEA3) */
14183                 TEST_CASE_ST(ut_setup, ut_teardown,
14184                         test_zuc_auth_cipher_test_case_1),
14185                 TEST_CASE_ST(ut_setup, ut_teardown,
14186                         test_zuc_auth_cipher_test_case_1_oop),
14187                 TEST_CASE_ST(ut_setup, ut_teardown,
14188                         test_zuc_auth_cipher_test_case_1_sgl),
14189                 TEST_CASE_ST(ut_setup, ut_teardown,
14190                         test_zuc_auth_cipher_test_case_1_oop_sgl),
14191
14192                 /** ZUC decrypt (EEA3), then verify auth */
14193                 TEST_CASE_ST(ut_setup, ut_teardown,
14194                         test_zuc_auth_cipher_verify_test_case_1),
14195                 TEST_CASE_ST(ut_setup, ut_teardown,
14196                         test_zuc_auth_cipher_verify_test_case_1_oop),
14197                 TEST_CASE_ST(ut_setup, ut_teardown,
14198                         test_zuc_auth_cipher_verify_test_case_1_sgl),
14199                 TEST_CASE_ST(ut_setup, ut_teardown,
14200                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
14201                 TEST_CASES_END()
14202         }
14203 };
14204
14205 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
14206         .suite_name = "HMAC_MD5 Authentication Test Suite",
14207         .setup = hmac_md5_auth_testsuite_setup,
14208         .unit_test_cases = {
14209                 TEST_CASE_ST(ut_setup, ut_teardown,
14210                         test_MD5_HMAC_generate_case_1),
14211                 TEST_CASE_ST(ut_setup, ut_teardown,
14212                         test_MD5_HMAC_verify_case_1),
14213                 TEST_CASE_ST(ut_setup, ut_teardown,
14214                         test_MD5_HMAC_generate_case_2),
14215                 TEST_CASE_ST(ut_setup, ut_teardown,
14216                         test_MD5_HMAC_verify_case_2),
14217                 TEST_CASES_END()
14218         }
14219 };
14220
14221 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
14222         .suite_name = "Kasumi Test Suite",
14223         .setup = kasumi_testsuite_setup,
14224         .unit_test_cases = {
14225                 /** KASUMI hash only (UIA1) */
14226                 TEST_CASE_ST(ut_setup, ut_teardown,
14227                         test_kasumi_hash_generate_test_case_1),
14228                 TEST_CASE_ST(ut_setup, ut_teardown,
14229                         test_kasumi_hash_generate_test_case_2),
14230                 TEST_CASE_ST(ut_setup, ut_teardown,
14231                         test_kasumi_hash_generate_test_case_3),
14232                 TEST_CASE_ST(ut_setup, ut_teardown,
14233                         test_kasumi_hash_generate_test_case_4),
14234                 TEST_CASE_ST(ut_setup, ut_teardown,
14235                         test_kasumi_hash_generate_test_case_5),
14236                 TEST_CASE_ST(ut_setup, ut_teardown,
14237                         test_kasumi_hash_generate_test_case_6),
14238
14239                 TEST_CASE_ST(ut_setup, ut_teardown,
14240                         test_kasumi_hash_verify_test_case_1),
14241                 TEST_CASE_ST(ut_setup, ut_teardown,
14242                         test_kasumi_hash_verify_test_case_2),
14243                 TEST_CASE_ST(ut_setup, ut_teardown,
14244                         test_kasumi_hash_verify_test_case_3),
14245                 TEST_CASE_ST(ut_setup, ut_teardown,
14246                         test_kasumi_hash_verify_test_case_4),
14247                 TEST_CASE_ST(ut_setup, ut_teardown,
14248                         test_kasumi_hash_verify_test_case_5),
14249
14250                 /** KASUMI encrypt only (UEA1) */
14251                 TEST_CASE_ST(ut_setup, ut_teardown,
14252                         test_kasumi_encryption_test_case_1),
14253                 TEST_CASE_ST(ut_setup, ut_teardown,
14254                         test_kasumi_encryption_test_case_1_sgl),
14255                 TEST_CASE_ST(ut_setup, ut_teardown,
14256                         test_kasumi_encryption_test_case_1_oop),
14257                 TEST_CASE_ST(ut_setup, ut_teardown,
14258                         test_kasumi_encryption_test_case_1_oop_sgl),
14259                 TEST_CASE_ST(ut_setup, ut_teardown,
14260                         test_kasumi_encryption_test_case_2),
14261                 TEST_CASE_ST(ut_setup, ut_teardown,
14262                         test_kasumi_encryption_test_case_3),
14263                 TEST_CASE_ST(ut_setup, ut_teardown,
14264                         test_kasumi_encryption_test_case_4),
14265                 TEST_CASE_ST(ut_setup, ut_teardown,
14266                         test_kasumi_encryption_test_case_5),
14267
14268                 /** KASUMI decrypt only (UEA1) */
14269                 TEST_CASE_ST(ut_setup, ut_teardown,
14270                         test_kasumi_decryption_test_case_1),
14271                 TEST_CASE_ST(ut_setup, ut_teardown,
14272                         test_kasumi_decryption_test_case_2),
14273                 TEST_CASE_ST(ut_setup, ut_teardown,
14274                         test_kasumi_decryption_test_case_3),
14275                 TEST_CASE_ST(ut_setup, ut_teardown,
14276                         test_kasumi_decryption_test_case_4),
14277                 TEST_CASE_ST(ut_setup, ut_teardown,
14278                         test_kasumi_decryption_test_case_5),
14279                 TEST_CASE_ST(ut_setup, ut_teardown,
14280                         test_kasumi_decryption_test_case_1_oop),
14281
14282                 TEST_CASE_ST(ut_setup, ut_teardown,
14283                         test_kasumi_cipher_auth_test_case_1),
14284
14285                 /** KASUMI generate auth, then encrypt (F8) */
14286                 TEST_CASE_ST(ut_setup, ut_teardown,
14287                         test_kasumi_auth_cipher_test_case_1),
14288                 TEST_CASE_ST(ut_setup, ut_teardown,
14289                         test_kasumi_auth_cipher_test_case_2),
14290                 TEST_CASE_ST(ut_setup, ut_teardown,
14291                         test_kasumi_auth_cipher_test_case_2_oop),
14292                 TEST_CASE_ST(ut_setup, ut_teardown,
14293                         test_kasumi_auth_cipher_test_case_2_sgl),
14294                 TEST_CASE_ST(ut_setup, ut_teardown,
14295                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
14296
14297                 /** KASUMI decrypt (F8), then verify auth */
14298                 TEST_CASE_ST(ut_setup, ut_teardown,
14299                         test_kasumi_auth_cipher_verify_test_case_1),
14300                 TEST_CASE_ST(ut_setup, ut_teardown,
14301                         test_kasumi_auth_cipher_verify_test_case_2),
14302                 TEST_CASE_ST(ut_setup, ut_teardown,
14303                         test_kasumi_auth_cipher_verify_test_case_2_oop),
14304                 TEST_CASE_ST(ut_setup, ut_teardown,
14305                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
14306                 TEST_CASE_ST(ut_setup, ut_teardown,
14307                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
14308
14309                 TEST_CASES_END()
14310         }
14311 };
14312
14313 static struct unit_test_suite cryptodev_esn_testsuite  = {
14314         .suite_name = "ESN Test Suite",
14315         .setup = esn_testsuite_setup,
14316         .unit_test_cases = {
14317                 TEST_CASE_ST(ut_setup, ut_teardown,
14318                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
14319                 TEST_CASE_ST(ut_setup, ut_teardown,
14320                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
14321                 TEST_CASES_END()
14322         }
14323 };
14324
14325 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
14326         .suite_name = "Negative AES GCM Test Suite",
14327         .setup = negative_aes_gcm_testsuite_setup,
14328         .unit_test_cases = {
14329                 TEST_CASE_ST(ut_setup, ut_teardown,
14330                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
14331                 TEST_CASE_ST(ut_setup, ut_teardown,
14332                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
14333                 TEST_CASE_ST(ut_setup, ut_teardown,
14334                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
14335                 TEST_CASE_ST(ut_setup, ut_teardown,
14336                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
14337                 TEST_CASE_ST(ut_setup, ut_teardown,
14338                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
14339                 TEST_CASE_ST(ut_setup, ut_teardown,
14340                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
14341                 TEST_CASE_ST(ut_setup, ut_teardown,
14342                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
14343                 TEST_CASE_ST(ut_setup, ut_teardown,
14344                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
14345                 TEST_CASE_ST(ut_setup, ut_teardown,
14346                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
14347                 TEST_CASE_ST(ut_setup, ut_teardown,
14348                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
14349                 TEST_CASE_ST(ut_setup, ut_teardown,
14350                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
14351                 TEST_CASE_ST(ut_setup, ut_teardown,
14352                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
14353
14354                 TEST_CASES_END()
14355         }
14356 };
14357
14358 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
14359         .suite_name = "Negative AES GMAC Test Suite",
14360         .setup = negative_aes_gmac_testsuite_setup,
14361         .unit_test_cases = {
14362                 TEST_CASE_ST(ut_setup, ut_teardown,
14363                         authentication_verify_AES128_GMAC_fail_data_corrupt),
14364                 TEST_CASE_ST(ut_setup, ut_teardown,
14365                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
14366
14367                 TEST_CASES_END()
14368         }
14369 };
14370
14371 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
14372         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
14373         .setup = mixed_cipher_hash_testsuite_setup,
14374         .unit_test_cases = {
14375                 /** AUTH AES CMAC + CIPHER AES CTR */
14376                 TEST_CASE_ST(ut_setup, ut_teardown,
14377                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
14378                 TEST_CASE_ST(ut_setup, ut_teardown,
14379                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14380                 TEST_CASE_ST(ut_setup, ut_teardown,
14381                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14382                 TEST_CASE_ST(ut_setup, ut_teardown,
14383                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14384                 TEST_CASE_ST(ut_setup, ut_teardown,
14385                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
14386                 TEST_CASE_ST(ut_setup, ut_teardown,
14387                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14388                 TEST_CASE_ST(ut_setup, ut_teardown,
14389                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14390                 TEST_CASE_ST(ut_setup, ut_teardown,
14391                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14392
14393                 /** AUTH ZUC + CIPHER SNOW3G */
14394                 TEST_CASE_ST(ut_setup, ut_teardown,
14395                         test_auth_zuc_cipher_snow_test_case_1),
14396                 TEST_CASE_ST(ut_setup, ut_teardown,
14397                         test_verify_auth_zuc_cipher_snow_test_case_1),
14398                 /** AUTH AES CMAC + CIPHER SNOW3G */
14399                 TEST_CASE_ST(ut_setup, ut_teardown,
14400                         test_auth_aes_cmac_cipher_snow_test_case_1),
14401                 TEST_CASE_ST(ut_setup, ut_teardown,
14402                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
14403                 /** AUTH ZUC + CIPHER AES CTR */
14404                 TEST_CASE_ST(ut_setup, ut_teardown,
14405                         test_auth_zuc_cipher_aes_ctr_test_case_1),
14406                 TEST_CASE_ST(ut_setup, ut_teardown,
14407                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
14408                 /** AUTH SNOW3G + CIPHER AES CTR */
14409                 TEST_CASE_ST(ut_setup, ut_teardown,
14410                         test_auth_snow_cipher_aes_ctr_test_case_1),
14411                 TEST_CASE_ST(ut_setup, ut_teardown,
14412                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
14413                 /** AUTH SNOW3G + CIPHER ZUC */
14414                 TEST_CASE_ST(ut_setup, ut_teardown,
14415                         test_auth_snow_cipher_zuc_test_case_1),
14416                 TEST_CASE_ST(ut_setup, ut_teardown,
14417                         test_verify_auth_snow_cipher_zuc_test_case_1),
14418                 /** AUTH AES CMAC + CIPHER ZUC */
14419                 TEST_CASE_ST(ut_setup, ut_teardown,
14420                         test_auth_aes_cmac_cipher_zuc_test_case_1),
14421                 TEST_CASE_ST(ut_setup, ut_teardown,
14422                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
14423
14424                 /** AUTH NULL + CIPHER SNOW3G */
14425                 TEST_CASE_ST(ut_setup, ut_teardown,
14426                         test_auth_null_cipher_snow_test_case_1),
14427                 TEST_CASE_ST(ut_setup, ut_teardown,
14428                         test_verify_auth_null_cipher_snow_test_case_1),
14429                 /** AUTH NULL + CIPHER ZUC */
14430                 TEST_CASE_ST(ut_setup, ut_teardown,
14431                         test_auth_null_cipher_zuc_test_case_1),
14432                 TEST_CASE_ST(ut_setup, ut_teardown,
14433                         test_verify_auth_null_cipher_zuc_test_case_1),
14434                 /** AUTH SNOW3G + CIPHER NULL */
14435                 TEST_CASE_ST(ut_setup, ut_teardown,
14436                         test_auth_snow_cipher_null_test_case_1),
14437                 TEST_CASE_ST(ut_setup, ut_teardown,
14438                         test_verify_auth_snow_cipher_null_test_case_1),
14439                 /** AUTH ZUC + CIPHER NULL */
14440                 TEST_CASE_ST(ut_setup, ut_teardown,
14441                         test_auth_zuc_cipher_null_test_case_1),
14442                 TEST_CASE_ST(ut_setup, ut_teardown,
14443                         test_verify_auth_zuc_cipher_null_test_case_1),
14444                 /** AUTH NULL + CIPHER AES CTR */
14445                 TEST_CASE_ST(ut_setup, ut_teardown,
14446                         test_auth_null_cipher_aes_ctr_test_case_1),
14447                 TEST_CASE_ST(ut_setup, ut_teardown,
14448                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
14449                 /** AUTH AES CMAC + CIPHER NULL */
14450                 TEST_CASE_ST(ut_setup, ut_teardown,
14451                         test_auth_aes_cmac_cipher_null_test_case_1),
14452                 TEST_CASE_ST(ut_setup, ut_teardown,
14453                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
14454                 TEST_CASES_END()
14455         }
14456 };
14457
14458 static int
14459 run_cryptodev_testsuite(const char *pmd_name)
14460 {
14461         uint8_t ret, j, i = 0, blk_start_idx = 0;
14462         const enum blockcipher_test_type blk_suites[] = {
14463                 BLKCIPHER_AES_CHAIN_TYPE,
14464                 BLKCIPHER_AES_CIPHERONLY_TYPE,
14465                 BLKCIPHER_AES_DOCSIS_TYPE,
14466                 BLKCIPHER_3DES_CHAIN_TYPE,
14467                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
14468                 BLKCIPHER_DES_CIPHERONLY_TYPE,
14469                 BLKCIPHER_DES_DOCSIS_TYPE,
14470                 BLKCIPHER_AUTHONLY_TYPE};
14471         struct unit_test_suite *static_suites[] = {
14472                 &cryptodev_multi_session_testsuite,
14473                 &cryptodev_null_testsuite,
14474                 &cryptodev_aes_ccm_auth_testsuite,
14475                 &cryptodev_aes_gcm_auth_testsuite,
14476                 &cryptodev_aes_gmac_auth_testsuite,
14477                 &cryptodev_snow3g_testsuite,
14478                 &cryptodev_chacha20_poly1305_testsuite,
14479                 &cryptodev_zuc_testsuite,
14480                 &cryptodev_hmac_md5_auth_testsuite,
14481                 &cryptodev_kasumi_testsuite,
14482                 &cryptodev_esn_testsuite,
14483                 &cryptodev_negative_aes_gcm_testsuite,
14484                 &cryptodev_negative_aes_gmac_testsuite,
14485                 &cryptodev_mixed_cipher_hash_testsuite,
14486                 &cryptodev_negative_hmac_sha1_testsuite,
14487                 &cryptodev_gen_testsuite,
14488 #ifdef RTE_LIB_SECURITY
14489                 &pdcp_proto_testsuite,
14490                 &docsis_proto_testsuite,
14491 #endif
14492                 &end_testsuite
14493         };
14494         static struct unit_test_suite ts = {
14495                 .suite_name = "Cryptodev Unit Test Suite",
14496                 .setup = testsuite_setup,
14497                 .teardown = testsuite_teardown,
14498                 .unit_test_cases = {TEST_CASES_END()}
14499         };
14500
14501         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
14502
14503         if (gbl_driver_id == -1) {
14504                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
14505                 return TEST_SKIPPED;
14506         }
14507
14508         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
14509                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
14510
14511         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
14512         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
14513         ret = unit_test_suite_runner(&ts);
14514
14515         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
14516         free(ts.unit_test_suites);
14517         return ret;
14518 }
14519
14520 static int
14521 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
14522 {
14523         struct rte_cryptodev_info dev_info;
14524         uint8_t i, nb_devs;
14525         int driver_id;
14526
14527         driver_id = rte_cryptodev_driver_id_get(pmd_name);
14528         if (driver_id == -1) {
14529                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
14530                 return TEST_SKIPPED;
14531         }
14532
14533         nb_devs = rte_cryptodev_count();
14534         if (nb_devs < 1) {
14535                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
14536                 return TEST_SKIPPED;
14537         }
14538
14539         for (i = 0; i < nb_devs; i++) {
14540                 rte_cryptodev_info_get(i, &dev_info);
14541                 if (dev_info.driver_id == driver_id) {
14542                         if (!(dev_info.feature_flags & flag)) {
14543                                 RTE_LOG(INFO, USER1, "%s not supported\n",
14544                                                 flag_name);
14545                                 return TEST_SKIPPED;
14546                         }
14547                         return 0; /* found */
14548                 }
14549         }
14550
14551         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
14552         return TEST_SKIPPED;
14553 }
14554
14555 static int
14556 test_cryptodev_qat(void)
14557 {
14558         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14559 }
14560
14561 static int
14562 test_cryptodev_virtio(void)
14563 {
14564         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
14565 }
14566
14567 static int
14568 test_cryptodev_aesni_mb(void)
14569 {
14570         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14571 }
14572
14573 static int
14574 test_cryptodev_cpu_aesni_mb(void)
14575 {
14576         int32_t rc;
14577         enum rte_security_session_action_type at = gbl_action_type;
14578         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14579         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14580         gbl_action_type = at;
14581         return rc;
14582 }
14583
14584 static int
14585 test_cryptodev_openssl(void)
14586 {
14587         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
14588 }
14589
14590 static int
14591 test_cryptodev_aesni_gcm(void)
14592 {
14593         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14594 }
14595
14596 static int
14597 test_cryptodev_cpu_aesni_gcm(void)
14598 {
14599         int32_t rc;
14600         enum rte_security_session_action_type at = gbl_action_type;
14601         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14602         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14603         gbl_action_type = at;
14604         return rc;
14605 }
14606
14607 static int
14608 test_cryptodev_mlx5(void)
14609 {
14610         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
14611 }
14612
14613 static int
14614 test_cryptodev_null(void)
14615 {
14616         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
14617 }
14618
14619 static int
14620 test_cryptodev_sw_snow3g(void)
14621 {
14622         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
14623 }
14624
14625 static int
14626 test_cryptodev_sw_kasumi(void)
14627 {
14628         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
14629 }
14630
14631 static int
14632 test_cryptodev_sw_zuc(void)
14633 {
14634         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
14635 }
14636
14637 static int
14638 test_cryptodev_armv8(void)
14639 {
14640         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
14641 }
14642
14643 static int
14644 test_cryptodev_mrvl(void)
14645 {
14646         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
14647 }
14648
14649 #ifdef RTE_CRYPTO_SCHEDULER
14650
14651 static int
14652 test_cryptodev_scheduler(void)
14653 {
14654         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
14655         const enum blockcipher_test_type blk_suites[] = {
14656                 BLKCIPHER_AES_CHAIN_TYPE,
14657                 BLKCIPHER_AES_CIPHERONLY_TYPE,
14658                 BLKCIPHER_AUTHONLY_TYPE
14659         };
14660         static struct unit_test_suite scheduler_multicore = {
14661                 .suite_name = "Scheduler Multicore Unit Test Suite",
14662                 .setup = scheduler_multicore_testsuite_setup,
14663                 .teardown = scheduler_mode_testsuite_teardown,
14664                 .unit_test_cases = {TEST_CASES_END()}
14665         };
14666         static struct unit_test_suite scheduler_round_robin = {
14667                 .suite_name = "Scheduler Round Robin Unit Test Suite",
14668                 .setup = scheduler_roundrobin_testsuite_setup,
14669                 .teardown = scheduler_mode_testsuite_teardown,
14670                 .unit_test_cases = {TEST_CASES_END()}
14671         };
14672         static struct unit_test_suite scheduler_failover = {
14673                 .suite_name = "Scheduler Failover Unit Test Suite",
14674                 .setup = scheduler_failover_testsuite_setup,
14675                 .teardown = scheduler_mode_testsuite_teardown,
14676                 .unit_test_cases = {TEST_CASES_END()}
14677         };
14678         static struct unit_test_suite scheduler_pkt_size_distr = {
14679                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
14680                 .setup = scheduler_pkt_size_distr_testsuite_setup,
14681                 .teardown = scheduler_mode_testsuite_teardown,
14682                 .unit_test_cases = {TEST_CASES_END()}
14683         };
14684         struct unit_test_suite *sched_mode_suites[] = {
14685                 &scheduler_multicore,
14686                 &scheduler_round_robin,
14687                 &scheduler_failover,
14688                 &scheduler_pkt_size_distr
14689         };
14690         static struct unit_test_suite scheduler_config = {
14691                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
14692                 .unit_test_cases = {
14693                         TEST_CASE(test_scheduler_attach_worker_op),
14694                         TEST_CASE(test_scheduler_mode_multicore_op),
14695                         TEST_CASE(test_scheduler_mode_roundrobin_op),
14696                         TEST_CASE(test_scheduler_mode_failover_op),
14697                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
14698                         TEST_CASE(test_scheduler_detach_worker_op),
14699
14700                         TEST_CASES_END() /**< NULL terminate array */
14701                 }
14702         };
14703         struct unit_test_suite *static_suites[] = {
14704                 &scheduler_config,
14705                 &end_testsuite
14706         };
14707         static struct unit_test_suite ts = {
14708                 .suite_name = "Scheduler Unit Test Suite",
14709                 .setup = scheduler_testsuite_setup,
14710                 .teardown = testsuite_teardown,
14711                 .unit_test_cases = {TEST_CASES_END()}
14712         };
14713
14714         gbl_driver_id = rte_cryptodev_driver_id_get(
14715                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14716
14717         if (gbl_driver_id == -1) {
14718                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
14719                 return TEST_SKIPPED;
14720         }
14721
14722         if (rte_cryptodev_driver_id_get(
14723                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
14724                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
14725                 return TEST_SKIPPED;
14726         }
14727
14728         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
14729                 uint8_t blk_i = 0;
14730                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
14731                                 (struct unit_test_suite *) *
14732                                 (RTE_DIM(blk_suites) + 1));
14733                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
14734                                 blk_suites, RTE_DIM(blk_suites));
14735                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
14736         }
14737
14738         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
14739                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
14740         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
14741                         RTE_DIM(sched_mode_suites));
14742         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
14743         ret = unit_test_suite_runner(&ts);
14744
14745         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
14746                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
14747                                 (*sched_mode_suites[sched_i]),
14748                                 RTE_DIM(blk_suites));
14749                 free(sched_mode_suites[sched_i]->unit_test_suites);
14750         }
14751         free(ts.unit_test_suites);
14752         return ret;
14753 }
14754
14755 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
14756
14757 #endif
14758
14759 static int
14760 test_cryptodev_dpaa2_sec(void)
14761 {
14762         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
14763 }
14764
14765 static int
14766 test_cryptodev_dpaa_sec(void)
14767 {
14768         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14769 }
14770
14771 static int
14772 test_cryptodev_ccp(void)
14773 {
14774         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14775 }
14776
14777 static int
14778 test_cryptodev_octeontx(void)
14779 {
14780         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14781 }
14782
14783 static int
14784 test_cryptodev_octeontx2(void)
14785 {
14786         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14787 }
14788
14789 static int
14790 test_cryptodev_caam_jr(void)
14791 {
14792         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14793 }
14794
14795 static int
14796 test_cryptodev_nitrox(void)
14797 {
14798         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14799 }
14800
14801 static int
14802 test_cryptodev_bcmfs(void)
14803 {
14804         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
14805 }
14806
14807 static int
14808 test_cryptodev_qat_raw_api(void)
14809 {
14810         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
14811         int ret;
14812
14813         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
14814                         "RAW API");
14815         if (ret)
14816                 return ret;
14817
14818         global_api_test_type = CRYPTODEV_RAW_API_TEST;
14819         ret = run_cryptodev_testsuite(pmd_name);
14820         global_api_test_type = CRYPTODEV_API_TEST;
14821
14822         return ret;
14823 }
14824
14825 static int
14826 test_cryptodev_cn9k(void)
14827 {
14828         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
14829 }
14830
14831 static int
14832 test_cryptodev_cn10k(void)
14833 {
14834         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
14835 }
14836
14837 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
14838                 test_cryptodev_qat_raw_api);
14839 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14840 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14841 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
14842         test_cryptodev_cpu_aesni_mb);
14843 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14844 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14845 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
14846         test_cryptodev_cpu_aesni_gcm);
14847 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
14848 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14849 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14850 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14851 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14852 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14853 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14854 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14855 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14856 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14857 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14858 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14859 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14860 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14861 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
14862 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
14863 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
14864 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);