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_ip.h>
  20 #include <rte_string_fns.h>
  21
  22 #ifdef RTE_CRYPTO_SCHEDULER
  23 #include <rte_cryptodev_scheduler.h>
  24 #include <rte_cryptodev_scheduler_operations.h>
  25 #endif
  26
  27 #include <rte_lcore.h>
  28
  29 #include "test.h"
  30 #include "test_cryptodev.h"
  31
  32 #include "test_cryptodev_blockcipher.h"
  33 #include "test_cryptodev_aes_test_vectors.h"
  34 #include "test_cryptodev_des_test_vectors.h"
  35 #include "test_cryptodev_hash_test_vectors.h"
  36 #include "test_cryptodev_kasumi_test_vectors.h"
  37 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  38 #include "test_cryptodev_snow3g_test_vectors.h"
  39 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  40 #include "test_cryptodev_zuc_test_vectors.h"
  41 #include "test_cryptodev_aead_test_vectors.h"
  42 #include "test_cryptodev_hmac_test_vectors.h"
  43 #include "test_cryptodev_mixed_test_vectors.h"
  44 #ifdef RTE_LIB_SECURITY
  45 #include "test_cryptodev_security_ipsec.h"
  46 #include "test_cryptodev_security_ipsec_test_vectors.h"
  47 #include "test_cryptodev_security_pdcp_test_vectors.h"
  48 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  49 #include "test_cryptodev_security_pdcp_test_func.h"
  50 #include "test_cryptodev_security_docsis_test_vectors.h"
  51
  52 #define SDAP_DISABLED   0
  53 #define SDAP_ENABLED    1
  54 #endif
  55
  56 #define VDEV_ARGS_SIZE 100
  57 #define MAX_NB_SESSIONS 4
  58
  59 #define MAX_DRV_SERVICE_CTX_SIZE 256
  60
  61 #define MAX_RAW_DEQUEUE_COUNT   65535
  62
  63 #define IN_PLACE 0
  64 #define OUT_OF_PLACE 1
  65
  66 static int gbl_driver_id;
  67
  68 static enum rte_security_session_action_type gbl_action_type =
  69         RTE_SECURITY_ACTION_TYPE_NONE;
  70
  71 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  72
  73 struct crypto_unittest_params {
  74         struct rte_crypto_sym_xform cipher_xform;
  75         struct rte_crypto_sym_xform auth_xform;
  76         struct rte_crypto_sym_xform aead_xform;
  77 #ifdef RTE_LIB_SECURITY
  78         struct rte_security_docsis_xform docsis_xform;
  79 #endif
  80
  81         union {
  82                 struct rte_cryptodev_sym_session *sess;
  83 #ifdef RTE_LIB_SECURITY
  84                 struct rte_security_session *sec_session;
  85 #endif
  86         };
  87 #ifdef RTE_LIB_SECURITY
  88         enum rte_security_session_action_type type;
  89 #endif
  90         struct rte_crypto_op *op;
  91
  92         struct rte_mbuf *obuf, *ibuf;
  93
  94         uint8_t *digest;
  95 };
  96
  97 #define ALIGN_POW2_ROUNDUP(num, align) \
  98         (((num) + (align) - 1) & ~((align) - 1))
  99
 100 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 101         for (j = 0; j < num_child_ts; index++, j++)                     \
 102                 parent_ts.unit_test_suites[index] = child_ts[j]
 103
 104 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 105         for (j = 0; j < num_blk_types; index++, j++)                            \
 106                 parent_ts.unit_test_suites[index] =                             \
 107                                 build_blockcipher_test_suite(blk_types[j])
 108
 109 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 110         for (j = index; j < index + num_blk_types; j++)                         \
 111                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 112
 113 /*
 114  * Forward declarations.
 115  */
 116 static int
 117 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 118                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 119                 uint8_t *hmac_key);
 120
 121 static int
 122 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 123                 struct crypto_unittest_params *ut_params,
 124                 struct crypto_testsuite_params *ts_param,
 125                 const uint8_t *cipher,
 126                 const uint8_t *digest,
 127                 const uint8_t *iv);
 128
 129 static int
 130 security_proto_supported(enum rte_security_session_action_type action,
 131         enum rte_security_session_protocol proto);
 132
 133 static int
 134 dev_configure_and_start(uint64_t ff_disable);
 135
 136 static struct rte_mbuf *
 137 setup_test_string(struct rte_mempool *mpool,
 138                 const char *string, size_t len, uint8_t blocksize)
 139 {
 140         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 141         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 142
 143         if (m) {
 144                 char *dst;
 145
 146                 memset(m->buf_addr, 0, m->buf_len);
 147                 dst = rte_pktmbuf_append(m, t_len);
 148                 if (!dst) {
 149                         rte_pktmbuf_free(m);
 150                         return NULL;
 151                 }
 152                 if (string != NULL)
 153                         rte_memcpy(dst, string, t_len);
 154                 else
 155                         memset(dst, 0, t_len);
 156         }
 157
 158         return m;
 159 }
 160
 161 /* Get number of bytes in X bits (rounding up) */
 162 static uint32_t
 163 ceil_byte_length(uint32_t num_bits)
 164 {
 165         if (num_bits % 8)
 166                 return ((num_bits >> 3) + 1);
 167         else
 168                 return (num_bits >> 3);
 169 }
 170
 171 static void
 172 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 173                 uint8_t is_op_success)
 174 {
 175         struct rte_crypto_op *op = user_data;
 176         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 177                         RTE_CRYPTO_OP_STATUS_ERROR;
 178 }
 179
 180 void
 181 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 182                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 183                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 184 {
 185         struct rte_crypto_sym_op *sop = op->sym;
 186         struct rte_crypto_op *ret_op = NULL;
 187         struct rte_crypto_vec data_vec[UINT8_MAX];
 188         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 189         union rte_crypto_sym_ofs ofs;
 190         struct rte_crypto_sym_vec vec;
 191         struct rte_crypto_sgl sgl;
 192         uint32_t max_len;
 193         union rte_cryptodev_session_ctx sess;
 194         uint32_t count = 0;
 195         struct rte_crypto_raw_dp_ctx *ctx;
 196         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 197                         auth_len = 0;
 198         int32_t n;
 199         uint32_t n_success;
 200         int ctx_service_size;
 201         int32_t status = 0;
 202         int enqueue_status, dequeue_status;
 203
 204         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 205         if (ctx_service_size < 0) {
 206                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 207                 return;
 208         }
 209
 210         ctx = malloc(ctx_service_size);
 211         if (!ctx) {
 212                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 213                 return;
 214         }
 215
 216         /* Both are enums, setting crypto_sess will suit any session type */
 217         sess.crypto_sess = op->sym->session;
 218
 219         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 220                         op->sess_type, sess, 0) < 0) {
 221                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 222                 goto exit;
 223         }
 224
 225         cipher_iv.iova = 0;
 226         cipher_iv.va = NULL;
 227         aad_auth_iv.iova = 0;
 228         aad_auth_iv.va = NULL;
 229         digest.iova = 0;
 230         digest.va = NULL;
 231         sgl.vec = data_vec;
 232         vec.num = 1;
 233         vec.sgl = &sgl;
 234         vec.iv = &cipher_iv;
 235         vec.digest = &digest;
 236         vec.aad = &aad_auth_iv;
 237         vec.status = &status;
 238
 239         ofs.raw = 0;
 240
 241         if (is_cipher && is_auth) {
 242                 cipher_offset = sop->cipher.data.offset;
 243                 cipher_len = sop->cipher.data.length;
 244                 auth_offset = sop->auth.data.offset;
 245                 auth_len = sop->auth.data.length;
 246                 max_len = RTE_MAX(cipher_offset + cipher_len,
 247                                 auth_offset + auth_len);
 248                 if (len_in_bits) {
 249                         max_len = max_len >> 3;
 250                         cipher_offset = cipher_offset >> 3;
 251                         auth_offset = auth_offset >> 3;
 252                         cipher_len = cipher_len >> 3;
 253                         auth_len = auth_len >> 3;
 254                 }
 255                 ofs.ofs.cipher.head = cipher_offset;
 256                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 257                 ofs.ofs.auth.head = auth_offset;
 258                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 259                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 260                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 261                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 262                                 op, void *, IV_OFFSET + cipher_iv_len);
 263                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 264                                 cipher_iv_len);
 265                 digest.va = (void *)sop->auth.digest.data;
 266                 digest.iova = sop->auth.digest.phys_addr;
 267
 268         } else if (is_cipher) {
 269                 cipher_offset = sop->cipher.data.offset;
 270                 cipher_len = sop->cipher.data.length;
 271                 max_len = cipher_len + cipher_offset;
 272                 if (len_in_bits) {
 273                         max_len = max_len >> 3;
 274                         cipher_offset = cipher_offset >> 3;
 275                         cipher_len = cipher_len >> 3;
 276                 }
 277                 ofs.ofs.cipher.head = cipher_offset;
 278                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 279                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 280                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 281
 282         } else if (is_auth) {
 283                 auth_offset = sop->auth.data.offset;
 284                 auth_len = sop->auth.data.length;
 285                 max_len = auth_len + auth_offset;
 286                 if (len_in_bits) {
 287                         max_len = max_len >> 3;
 288                         auth_offset = auth_offset >> 3;
 289                         auth_len = auth_len >> 3;
 290                 }
 291                 ofs.ofs.auth.head = auth_offset;
 292                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 293                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 294                                 op, void *, IV_OFFSET + cipher_iv_len);
 295                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 296                                 cipher_iv_len);
 297                 digest.va = (void *)sop->auth.digest.data;
 298                 digest.iova = sop->auth.digest.phys_addr;
 299
 300         } else { /* aead */
 301                 cipher_offset = sop->aead.data.offset;
 302                 cipher_len = sop->aead.data.length;
 303                 max_len = cipher_len + cipher_offset;
 304                 if (len_in_bits) {
 305                         max_len = max_len >> 3;
 306                         cipher_offset = cipher_offset >> 3;
 307                         cipher_len = cipher_len >> 3;
 308                 }
 309                 ofs.ofs.cipher.head = cipher_offset;
 310                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 311                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 312                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 313                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 314                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 315                 digest.va = (void *)sop->aead.digest.data;
 316                 digest.iova = sop->aead.digest.phys_addr;
 317         }
 318
 319         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 320                         data_vec, RTE_DIM(data_vec));
 321         if (n < 0 || n > sop->m_src->nb_segs) {
 322                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 323                 goto exit;
 324         }
 325
 326         sgl.num = n;
 327
 328         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 329                         &enqueue_status) < 1) {
 330                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 331                 goto exit;
 332         }
 333
 334         if (enqueue_status == 0) {
 335                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 336                 if (status < 0) {
 337                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 338                         goto exit;
 339                 }
 340         } else if (enqueue_status < 0) {
 341                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 342                 goto exit;
 343         }
 344
 345         n = n_success = 0;
 346         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 347                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 348                         NULL, 1, post_process_raw_dp_op,
 349                                 (void **)&ret_op, 0, &n_success,
 350                                 &dequeue_status);
 351                 if (dequeue_status < 0) {
 352                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 353                         goto exit;
 354                 }
 355                 if (n == 0)
 356                         rte_pause();
 357         }
 358
 359         if (n == 1 && dequeue_status == 0) {
 360                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 361                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 362                         goto exit;
 363                 }
 364         }
 365
 366         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 367                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 368                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 369
 370 exit:
 371         free(ctx);
 372 }
 373
 374 static void
 375 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 376 {
 377         int32_t n, st;
 378         struct rte_crypto_sym_op *sop;
 379         union rte_crypto_sym_ofs ofs;
 380         struct rte_crypto_sgl sgl;
 381         struct rte_crypto_sym_vec symvec;
 382         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 383         struct rte_crypto_vec vec[UINT8_MAX];
 384
 385         sop = op->sym;
 386
 387         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 388                 sop->aead.data.length, vec, RTE_DIM(vec));
 389
 390         if (n < 0 || n != sop->m_src->nb_segs) {
 391                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 392                 return;
 393         }
 394
 395         sgl.vec = vec;
 396         sgl.num = n;
 397         symvec.sgl = &sgl;
 398         symvec.iv = &iv_ptr;
 399         symvec.digest = &digest_ptr;
 400         symvec.aad = &aad_ptr;
 401         symvec.status = &st;
 402         symvec.num = 1;
 403
 404         /* for CPU crypto the IOVA address is not required */
 405         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 406         digest_ptr.va = (void *)sop->aead.digest.data;
 407         aad_ptr.va = (void *)sop->aead.aad.data;
 408
 409         ofs.raw = 0;
 410
 411         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 412                 &symvec);
 413
 414         if (n != 1)
 415                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 416         else
 417                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 418 }
 419
 420 static void
 421 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 422 {
 423         int32_t n, st;
 424         struct rte_crypto_sym_op *sop;
 425         union rte_crypto_sym_ofs ofs;
 426         struct rte_crypto_sgl sgl;
 427         struct rte_crypto_sym_vec symvec;
 428         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 429         struct rte_crypto_vec vec[UINT8_MAX];
 430
 431         sop = op->sym;
 432
 433         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 434                 sop->auth.data.length, vec, RTE_DIM(vec));
 435
 436         if (n < 0 || n != sop->m_src->nb_segs) {
 437                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 438                 return;
 439         }
 440
 441         sgl.vec = vec;
 442         sgl.num = n;
 443         symvec.sgl = &sgl;
 444         symvec.iv = &iv_ptr;
 445         symvec.digest = &digest_ptr;
 446         symvec.status = &st;
 447         symvec.num = 1;
 448
 449         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 450         digest_ptr.va = (void *)sop->auth.digest.data;
 451
 452         ofs.raw = 0;
 453         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 454         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 455                 (sop->cipher.data.offset + sop->cipher.data.length);
 456
 457         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 458                 &symvec);
 459
 460         if (n != 1)
 461                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 462         else
 463                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 464 }
 465
 466 static struct rte_crypto_op *
 467 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 468 {
 469
 470         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 471
 472         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 473                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 474                 return NULL;
 475         }
 476
 477         op = NULL;
 478
 479         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 480                 rte_pause();
 481
 482         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 483                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 484                 return NULL;
 485         }
 486
 487         return op;
 488 }
 489
 490 static struct crypto_testsuite_params testsuite_params = { NULL };
 491 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 492 static struct crypto_unittest_params unittest_params;
 493
 494 static int
 495 testsuite_setup(void)
 496 {
 497         struct crypto_testsuite_params *ts_params = &testsuite_params;
 498         struct rte_cryptodev_info info;
 499         uint32_t i = 0, nb_devs, dev_id;
 500         uint16_t qp_id;
 501
 502         memset(ts_params, 0, sizeof(*ts_params));
 503
 504         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 505         if (ts_params->mbuf_pool == NULL) {
 506                 /* Not already created so create */
 507                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 508                                 "CRYPTO_MBUFPOOL",
 509                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 510                                 rte_socket_id());
 511                 if (ts_params->mbuf_pool == NULL) {
 512                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 513                         return TEST_FAILED;
 514                 }
 515         }
 516
 517         ts_params->large_mbuf_pool = rte_mempool_lookup(
 518                         "CRYPTO_LARGE_MBUFPOOL");
 519         if (ts_params->large_mbuf_pool == NULL) {
 520                 /* Not already created so create */
 521                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 522                                 "CRYPTO_LARGE_MBUFPOOL",
 523                                 1, 0, 0, UINT16_MAX,
 524                                 rte_socket_id());
 525                 if (ts_params->large_mbuf_pool == NULL) {
 526                         RTE_LOG(ERR, USER1,
 527                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 528                         return TEST_FAILED;
 529                 }
 530         }
 531
 532         ts_params->op_mpool = rte_crypto_op_pool_create(
 533                         "MBUF_CRYPTO_SYM_OP_POOL",
 534                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 535                         NUM_MBUFS, MBUF_CACHE_SIZE,
 536                         DEFAULT_NUM_XFORMS *
 537                         sizeof(struct rte_crypto_sym_xform) +
 538                         MAXIMUM_IV_LENGTH,
 539                         rte_socket_id());
 540         if (ts_params->op_mpool == NULL) {
 541                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 542                 return TEST_FAILED;
 543         }
 544
 545         nb_devs = rte_cryptodev_count();
 546         if (nb_devs < 1) {
 547                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 548                 return TEST_SKIPPED;
 549         }
 550
 551         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 552                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 553                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 554                 return TEST_SKIPPED;
 555         }
 556
 557         /* Create list of valid crypto devs */
 558         for (i = 0; i < nb_devs; i++) {
 559                 rte_cryptodev_info_get(i, &info);
 560                 if (info.driver_id == gbl_driver_id)
 561                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 562         }
 563
 564         if (ts_params->valid_dev_count < 1)
 565                 return TEST_FAILED;
 566
 567         /* Set up all the qps on the first of the valid devices found */
 568
 569         dev_id = ts_params->valid_devs[0];
 570
 571         rte_cryptodev_info_get(dev_id, &info);
 572
 573         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 574         ts_params->conf.socket_id = SOCKET_ID_ANY;
 575         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 576
 577         unsigned int session_size =
 578                 rte_cryptodev_sym_get_private_session_size(dev_id);
 579
 580 #ifdef RTE_LIB_SECURITY
 581         unsigned int security_session_size = rte_security_session_get_size(
 582                         rte_cryptodev_get_sec_ctx(dev_id));
 583
 584         if (session_size < security_session_size)
 585                 session_size = security_session_size;
 586 #endif
 587         /*
 588          * Create mempool with maximum number of sessions.
 589          */
 590         if (info.sym.max_nb_sessions != 0 &&
 591                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 592                 RTE_LOG(ERR, USER1, "Device does not support "
 593                                 "at least %u sessions\n",
 594                                 MAX_NB_SESSIONS);
 595                 return TEST_FAILED;
 596         }
 597
 598         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 599                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 600                         SOCKET_ID_ANY);
 601         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 602                         "session mempool allocation failed");
 603
 604         ts_params->session_priv_mpool = rte_mempool_create(
 605                         "test_sess_mp_priv",
 606                         MAX_NB_SESSIONS,
 607                         session_size,
 608                         0, 0, NULL, NULL, NULL,
 609                         NULL, SOCKET_ID_ANY,
 610                         0);
 611         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 612                         "session mempool allocation failed");
 613
 614
 615
 616         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 617                         &ts_params->conf),
 618                         "Failed to configure cryptodev %u with %u qps",
 619                         dev_id, ts_params->conf.nb_queue_pairs);
 620
 621         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 622         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 623         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 624
 625         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 626                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 627                         dev_id, qp_id, &ts_params->qp_conf,
 628                         rte_cryptodev_socket_id(dev_id)),
 629                         "Failed to setup queue pair %u on cryptodev %u",
 630                         qp_id, dev_id);
 631         }
 632
 633         return TEST_SUCCESS;
 634 }
 635
 636 static void
 637 testsuite_teardown(void)
 638 {
 639         struct crypto_testsuite_params *ts_params = &testsuite_params;
 640         int res;
 641
 642         if (ts_params->mbuf_pool != NULL) {
 643                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 644                 rte_mempool_avail_count(ts_params->mbuf_pool));
 645         }
 646
 647         if (ts_params->op_mpool != NULL) {
 648                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 649                 rte_mempool_avail_count(ts_params->op_mpool));
 650         }
 651
 652         /* Free session mempools */
 653         if (ts_params->session_priv_mpool != NULL) {
 654                 rte_mempool_free(ts_params->session_priv_mpool);
 655                 ts_params->session_priv_mpool = NULL;
 656         }
 657
 658         if (ts_params->session_mpool != NULL) {
 659                 rte_mempool_free(ts_params->session_mpool);
 660                 ts_params->session_mpool = NULL;
 661         }
 662
 663         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 664         if (res)
 665                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 666 }
 667
 668 static int
 669 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 670                 const int *algs, uint16_t num_algs)
 671 {
 672         uint8_t dev_id = testsuite_params.valid_devs[0];
 673         bool some_alg_supported = FALSE;
 674         uint16_t i;
 675
 676         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 677                 struct rte_cryptodev_sym_capability_idx alg = {
 678                         type, {algs[i]}
 679                 };
 680                 if (rte_cryptodev_sym_capability_get(dev_id,
 681                                 &alg) != NULL)
 682                         some_alg_supported = TRUE;
 683         }
 684         if (!some_alg_supported)
 685                 return TEST_SKIPPED;
 686
 687         return 0;
 688 }
 689
 690 int
 691 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 692                 uint16_t num_ciphers)
 693 {
 694         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 695                         (const int *) ciphers, num_ciphers);
 696 }
 697
 698 int
 699 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 700                 uint16_t num_auths)
 701 {
 702         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 703                         (const int *) auths, num_auths);
 704 }
 705
 706 int
 707 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 708                 uint16_t num_aeads)
 709 {
 710         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 711                         (const int *) aeads, num_aeads);
 712 }
 713
 714 static int
 715 null_testsuite_setup(void)
 716 {
 717         struct crypto_testsuite_params *ts_params = &testsuite_params;
 718         uint8_t dev_id = ts_params->valid_devs[0];
 719         struct rte_cryptodev_info dev_info;
 720         const enum rte_crypto_cipher_algorithm ciphers[] = {
 721                 RTE_CRYPTO_CIPHER_NULL
 722         };
 723         const enum rte_crypto_auth_algorithm auths[] = {
 724                 RTE_CRYPTO_AUTH_NULL
 725         };
 726
 727         rte_cryptodev_info_get(dev_id, &dev_info);
 728
 729         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 730                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 731                                 "testsuite not met\n");
 732                 return TEST_SKIPPED;
 733         }
 734
 735         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 736                         && check_auth_capabilities_supported(auths,
 737                         RTE_DIM(auths)) != 0) {
 738                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 739                                 "testsuite not met\n");
 740                 return TEST_SKIPPED;
 741         }
 742
 743         return 0;
 744 }
 745
 746 static int
 747 crypto_gen_testsuite_setup(void)
 748 {
 749         struct crypto_testsuite_params *ts_params = &testsuite_params;
 750         uint8_t dev_id = ts_params->valid_devs[0];
 751         struct rte_cryptodev_info dev_info;
 752
 753         rte_cryptodev_info_get(dev_id, &dev_info);
 754
 755         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 756                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 757                                 "testsuite not met\n");
 758                 return TEST_SKIPPED;
 759         }
 760
 761         return 0;
 762 }
 763
 764 #ifdef RTE_LIB_SECURITY
 765 static int
 766 ipsec_proto_testsuite_setup(void)
 767 {
 768         struct crypto_testsuite_params *ts_params = &testsuite_params;
 769         struct crypto_unittest_params *ut_params = &unittest_params;
 770         struct rte_cryptodev_info dev_info;
 771         int ret = 0;
 772
 773         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 774
 775         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 776                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 777                                 "testsuite not met\n");
 778                 return TEST_SKIPPED;
 779         }
 780
 781         /* Reconfigure to enable security */
 782         ret = dev_configure_and_start(0);
 783         if (ret != TEST_SUCCESS)
 784                 return ret;
 785
 786         /* Set action type */
 787         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 788
 789         if (security_proto_supported(
 790                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 791                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 792                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 793                                 "test not met\n");
 794                 ret = TEST_SKIPPED;
 795         }
 796
 797         /*
 798          * Stop the device. Device would be started again by individual test
 799          * case setup routine.
 800          */
 801         rte_cryptodev_stop(ts_params->valid_devs[0]);
 802
 803         return ret;
 804 }
 805
 806 static int
 807 pdcp_proto_testsuite_setup(void)
 808 {
 809         struct crypto_testsuite_params *ts_params = &testsuite_params;
 810         uint8_t dev_id = ts_params->valid_devs[0];
 811         struct rte_cryptodev_info dev_info;
 812         const enum rte_crypto_cipher_algorithm ciphers[] = {
 813                 RTE_CRYPTO_CIPHER_NULL,
 814                 RTE_CRYPTO_CIPHER_AES_CTR,
 815                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 816                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 817         };
 818         const enum rte_crypto_auth_algorithm auths[] = {
 819                 RTE_CRYPTO_AUTH_NULL,
 820                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 821                 RTE_CRYPTO_AUTH_AES_CMAC,
 822                 RTE_CRYPTO_AUTH_ZUC_EIA3
 823         };
 824
 825         rte_cryptodev_info_get(dev_id, &dev_info);
 826
 827         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 828                         !(dev_info.feature_flags &
 829                         RTE_CRYPTODEV_FF_SECURITY)) {
 830                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 831                                 "testsuite not met\n");
 832                 return TEST_SKIPPED;
 833         }
 834
 835         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 836                         && check_auth_capabilities_supported(auths,
 837                         RTE_DIM(auths)) != 0) {
 838                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 839                                 "testsuite not met\n");
 840                 return TEST_SKIPPED;
 841         }
 842
 843         return 0;
 844 }
 845
 846 static int
 847 docsis_proto_testsuite_setup(void)
 848 {
 849         struct crypto_testsuite_params *ts_params = &testsuite_params;
 850         uint8_t dev_id = ts_params->valid_devs[0];
 851         struct rte_cryptodev_info dev_info;
 852         const enum rte_crypto_cipher_algorithm ciphers[] = {
 853                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 854         };
 855
 856         rte_cryptodev_info_get(dev_id, &dev_info);
 857
 858         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 859                         !(dev_info.feature_flags &
 860                         RTE_CRYPTODEV_FF_SECURITY)) {
 861                 RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis "
 862                                 "Proto testsuite not met\n");
 863                 return TEST_SKIPPED;
 864         }
 865
 866         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 867                 RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto "
 868                                 "testsuite not met\n");
 869                 return TEST_SKIPPED;
 870         }
 871
 872         return 0;
 873 }
 874 #endif
 875
 876 static int
 877 aes_ccm_auth_testsuite_setup(void)
 878 {
 879         struct crypto_testsuite_params *ts_params = &testsuite_params;
 880         uint8_t dev_id = ts_params->valid_devs[0];
 881         struct rte_cryptodev_info dev_info;
 882         const enum rte_crypto_aead_algorithm aeads[] = {
 883                 RTE_CRYPTO_AEAD_AES_CCM
 884         };
 885
 886         rte_cryptodev_info_get(dev_id, &dev_info);
 887
 888         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 889                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 890                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 891                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 892                                 "testsuite not met\n");
 893                 return TEST_SKIPPED;
 894         }
 895
 896         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 897                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 898                                 "testsuite not met\n");
 899                 return TEST_SKIPPED;
 900         }
 901
 902         return 0;
 903 }
 904
 905 static int
 906 aes_gcm_auth_testsuite_setup(void)
 907 {
 908         struct crypto_testsuite_params *ts_params = &testsuite_params;
 909         uint8_t dev_id = ts_params->valid_devs[0];
 910         struct rte_cryptodev_info dev_info;
 911         const enum rte_crypto_aead_algorithm aeads[] = {
 912                 RTE_CRYPTO_AEAD_AES_GCM
 913         };
 914
 915         rte_cryptodev_info_get(dev_id, &dev_info);
 916
 917         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 918                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 919                                 "testsuite not met\n");
 920                 return TEST_SKIPPED;
 921         }
 922
 923         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 924                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 925                                 "testsuite not met\n");
 926                 return TEST_SKIPPED;
 927         }
 928
 929         return 0;
 930 }
 931
 932 static int
 933 aes_gmac_auth_testsuite_setup(void)
 934 {
 935         struct crypto_testsuite_params *ts_params = &testsuite_params;
 936         uint8_t dev_id = ts_params->valid_devs[0];
 937         struct rte_cryptodev_info dev_info;
 938         const enum rte_crypto_auth_algorithm auths[] = {
 939                 RTE_CRYPTO_AUTH_AES_GMAC
 940         };
 941
 942         rte_cryptodev_info_get(dev_id, &dev_info);
 943
 944         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 945                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 946                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 947                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
 948                                 "testsuite not met\n");
 949                 return TEST_SKIPPED;
 950         }
 951
 952         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
 953                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
 954                                 "testsuite not met\n");
 955                 return TEST_SKIPPED;
 956         }
 957
 958         return 0;
 959 }
 960
 961 static int
 962 chacha20_poly1305_testsuite_setup(void)
 963 {
 964         struct crypto_testsuite_params *ts_params = &testsuite_params;
 965         uint8_t dev_id = ts_params->valid_devs[0];
 966         struct rte_cryptodev_info dev_info;
 967         const enum rte_crypto_aead_algorithm aeads[] = {
 968                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
 969         };
 970
 971         rte_cryptodev_info_get(dev_id, &dev_info);
 972
 973         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 974                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 975                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 976                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
 977                                 "Chacha20-Poly1305 testsuite not met\n");
 978                 return TEST_SKIPPED;
 979         }
 980
 981         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 982                 RTE_LOG(INFO, USER1, "Capability requirements for "
 983                                 "Chacha20-Poly1305 testsuite not met\n");
 984                 return TEST_SKIPPED;
 985         }
 986
 987         return 0;
 988 }
 989
 990 static int
 991 snow3g_testsuite_setup(void)
 992 {
 993         struct crypto_testsuite_params *ts_params = &testsuite_params;
 994         uint8_t dev_id = ts_params->valid_devs[0];
 995         struct rte_cryptodev_info dev_info;
 996         const enum rte_crypto_cipher_algorithm ciphers[] = {
 997                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 998
 999         };
1000         const enum rte_crypto_auth_algorithm auths[] = {
1001                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1002         };
1003
1004         rte_cryptodev_info_get(dev_id, &dev_info);
1005
1006         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1007                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1008                                 "testsuite not met\n");
1009                 return TEST_SKIPPED;
1010         }
1011
1012         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1013                         && check_auth_capabilities_supported(auths,
1014                         RTE_DIM(auths)) != 0) {
1015                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1016                                 "testsuite not met\n");
1017                 return TEST_SKIPPED;
1018         }
1019
1020         return 0;
1021 }
1022
1023 static int
1024 zuc_testsuite_setup(void)
1025 {
1026         struct crypto_testsuite_params *ts_params = &testsuite_params;
1027         uint8_t dev_id = ts_params->valid_devs[0];
1028         struct rte_cryptodev_info dev_info;
1029         const enum rte_crypto_cipher_algorithm ciphers[] = {
1030                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1031         };
1032         const enum rte_crypto_auth_algorithm auths[] = {
1033                 RTE_CRYPTO_AUTH_ZUC_EIA3
1034         };
1035
1036         rte_cryptodev_info_get(dev_id, &dev_info);
1037
1038         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1039                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1040                                 "testsuite not met\n");
1041                 return TEST_SKIPPED;
1042         }
1043
1044         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1045                         && check_auth_capabilities_supported(auths,
1046                         RTE_DIM(auths)) != 0) {
1047                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1048                                 "testsuite not met\n");
1049                 return TEST_SKIPPED;
1050         }
1051
1052         return 0;
1053 }
1054
1055 static int
1056 hmac_md5_auth_testsuite_setup(void)
1057 {
1058         struct crypto_testsuite_params *ts_params = &testsuite_params;
1059         uint8_t dev_id = ts_params->valid_devs[0];
1060         struct rte_cryptodev_info dev_info;
1061         const enum rte_crypto_auth_algorithm auths[] = {
1062                 RTE_CRYPTO_AUTH_MD5_HMAC
1063         };
1064
1065         rte_cryptodev_info_get(dev_id, &dev_info);
1066
1067         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1068                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1069                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1070                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1071                                 "Auth testsuite not met\n");
1072                 return TEST_SKIPPED;
1073         }
1074
1075         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1076                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1077                                 "testsuite not met\n");
1078                 return TEST_SKIPPED;
1079         }
1080
1081         return 0;
1082 }
1083
1084 static int
1085 kasumi_testsuite_setup(void)
1086 {
1087         struct crypto_testsuite_params *ts_params = &testsuite_params;
1088         uint8_t dev_id = ts_params->valid_devs[0];
1089         struct rte_cryptodev_info dev_info;
1090         const enum rte_crypto_cipher_algorithm ciphers[] = {
1091                 RTE_CRYPTO_CIPHER_KASUMI_F8
1092         };
1093         const enum rte_crypto_auth_algorithm auths[] = {
1094                 RTE_CRYPTO_AUTH_KASUMI_F9
1095         };
1096
1097         rte_cryptodev_info_get(dev_id, &dev_info);
1098
1099         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1100                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1101                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1102                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1103                                 "testsuite not met\n");
1104                 return TEST_SKIPPED;
1105         }
1106
1107         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1108                         && check_auth_capabilities_supported(auths,
1109                         RTE_DIM(auths)) != 0) {
1110                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1111                                 "testsuite not met\n");
1112                 return TEST_SKIPPED;
1113         }
1114
1115         return 0;
1116 }
1117
1118 static int
1119 negative_aes_gcm_testsuite_setup(void)
1120 {
1121         struct crypto_testsuite_params *ts_params = &testsuite_params;
1122         uint8_t dev_id = ts_params->valid_devs[0];
1123         struct rte_cryptodev_info dev_info;
1124         const enum rte_crypto_aead_algorithm aeads[] = {
1125                 RTE_CRYPTO_AEAD_AES_GCM
1126         };
1127
1128         rte_cryptodev_info_get(dev_id, &dev_info);
1129
1130         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1131                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1132                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1133                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1134                                 "AES GCM testsuite not met\n");
1135                 return TEST_SKIPPED;
1136         }
1137
1138         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1139                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1140                                 "AES GCM testsuite not met\n");
1141                 return TEST_SKIPPED;
1142         }
1143
1144         return 0;
1145 }
1146
1147 static int
1148 negative_aes_gmac_testsuite_setup(void)
1149 {
1150         struct crypto_testsuite_params *ts_params = &testsuite_params;
1151         uint8_t dev_id = ts_params->valid_devs[0];
1152         struct rte_cryptodev_info dev_info;
1153         const enum rte_crypto_auth_algorithm auths[] = {
1154                 RTE_CRYPTO_AUTH_AES_GMAC
1155         };
1156
1157         rte_cryptodev_info_get(dev_id, &dev_info);
1158
1159         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1160                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1161                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1162                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1163                                 "AES GMAC testsuite not met\n");
1164                 return TEST_SKIPPED;
1165         }
1166
1167         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1168                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1169                                 "AES GMAC testsuite not met\n");
1170                 return TEST_SKIPPED;
1171         }
1172
1173         return 0;
1174 }
1175
1176 static int
1177 mixed_cipher_hash_testsuite_setup(void)
1178 {
1179         struct crypto_testsuite_params *ts_params = &testsuite_params;
1180         uint8_t dev_id = ts_params->valid_devs[0];
1181         struct rte_cryptodev_info dev_info;
1182         uint64_t feat_flags;
1183         const enum rte_crypto_cipher_algorithm ciphers[] = {
1184                 RTE_CRYPTO_CIPHER_NULL,
1185                 RTE_CRYPTO_CIPHER_AES_CTR,
1186                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1187                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1188         };
1189         const enum rte_crypto_auth_algorithm auths[] = {
1190                 RTE_CRYPTO_AUTH_NULL,
1191                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1192                 RTE_CRYPTO_AUTH_AES_CMAC,
1193                 RTE_CRYPTO_AUTH_ZUC_EIA3
1194         };
1195
1196         rte_cryptodev_info_get(dev_id, &dev_info);
1197         feat_flags = dev_info.feature_flags;
1198
1199         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1200                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1201                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1202                                 "Cipher Hash testsuite not met\n");
1203                 return TEST_SKIPPED;
1204         }
1205
1206         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1207                         && check_auth_capabilities_supported(auths,
1208                         RTE_DIM(auths)) != 0) {
1209                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1210                                 "Cipher Hash testsuite not met\n");
1211                 return TEST_SKIPPED;
1212         }
1213
1214         return 0;
1215 }
1216
1217 static int
1218 esn_testsuite_setup(void)
1219 {
1220         struct crypto_testsuite_params *ts_params = &testsuite_params;
1221         uint8_t dev_id = ts_params->valid_devs[0];
1222         struct rte_cryptodev_info dev_info;
1223         const enum rte_crypto_cipher_algorithm ciphers[] = {
1224                 RTE_CRYPTO_CIPHER_AES_CBC
1225         };
1226         const enum rte_crypto_auth_algorithm auths[] = {
1227                 RTE_CRYPTO_AUTH_SHA1_HMAC
1228         };
1229
1230         rte_cryptodev_info_get(dev_id, &dev_info);
1231
1232         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1233                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1234                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1235                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1236                                 "testsuite not met\n");
1237                 return TEST_SKIPPED;
1238         }
1239
1240         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1241                         && check_auth_capabilities_supported(auths,
1242                         RTE_DIM(auths)) != 0) {
1243                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1244                                 "testsuite not met\n");
1245                 return TEST_SKIPPED;
1246         }
1247
1248         return 0;
1249 }
1250
1251 static int
1252 multi_session_testsuite_setup(void)
1253 {
1254         struct crypto_testsuite_params *ts_params = &testsuite_params;
1255         uint8_t dev_id = ts_params->valid_devs[0];
1256         struct rte_cryptodev_info dev_info;
1257         const enum rte_crypto_cipher_algorithm ciphers[] = {
1258                 RTE_CRYPTO_CIPHER_AES_CBC
1259         };
1260         const enum rte_crypto_auth_algorithm auths[] = {
1261                 RTE_CRYPTO_AUTH_SHA512_HMAC
1262         };
1263
1264         rte_cryptodev_info_get(dev_id, &dev_info);
1265
1266         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1267                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1268                                 "Session testsuite not met\n");
1269                 return TEST_SKIPPED;
1270         }
1271
1272         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1273                         && check_auth_capabilities_supported(auths,
1274                         RTE_DIM(auths)) != 0) {
1275                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1276                                 "Session testsuite not met\n");
1277                 return TEST_SKIPPED;
1278         }
1279
1280         return 0;
1281 }
1282
1283 static int
1284 negative_hmac_sha1_testsuite_setup(void)
1285 {
1286         struct crypto_testsuite_params *ts_params = &testsuite_params;
1287         uint8_t dev_id = ts_params->valid_devs[0];
1288         struct rte_cryptodev_info dev_info;
1289         const enum rte_crypto_cipher_algorithm ciphers[] = {
1290                 RTE_CRYPTO_CIPHER_AES_CBC
1291         };
1292         const enum rte_crypto_auth_algorithm auths[] = {
1293                 RTE_CRYPTO_AUTH_SHA1_HMAC
1294         };
1295
1296         rte_cryptodev_info_get(dev_id, &dev_info);
1297
1298         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1299                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1300                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1301                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1302                                 "HMAC SHA1 testsuite not met\n");
1303                 return TEST_SKIPPED;
1304         }
1305
1306         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1307                         && check_auth_capabilities_supported(auths,
1308                         RTE_DIM(auths)) != 0) {
1309                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1310                                 "HMAC SHA1 testsuite not met\n");
1311                 return TEST_SKIPPED;
1312         }
1313
1314         return 0;
1315 }
1316
1317 static int
1318 dev_configure_and_start(uint64_t ff_disable)
1319 {
1320         struct crypto_testsuite_params *ts_params = &testsuite_params;
1321         struct crypto_unittest_params *ut_params = &unittest_params;
1322
1323         uint16_t qp_id;
1324
1325         /* Clear unit test parameters before running test */
1326         memset(ut_params, 0, sizeof(*ut_params));
1327
1328         /* Reconfigure device to default parameters */
1329         ts_params->conf.socket_id = SOCKET_ID_ANY;
1330         ts_params->conf.ff_disable = ff_disable;
1331         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1332         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1333         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1334
1335         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1336                         &ts_params->conf),
1337                         "Failed to configure cryptodev %u",
1338                         ts_params->valid_devs[0]);
1339
1340         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1341                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1342                         ts_params->valid_devs[0], qp_id,
1343                         &ts_params->qp_conf,
1344                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1345                         "Failed to setup queue pair %u on cryptodev %u",
1346                         qp_id, ts_params->valid_devs[0]);
1347         }
1348
1349
1350         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1351
1352         /* Start the device */
1353         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1354                         "Failed to start cryptodev %u",
1355                         ts_params->valid_devs[0]);
1356
1357         return TEST_SUCCESS;
1358 }
1359
1360 int
1361 ut_setup(void)
1362 {
1363         /* Configure and start the device with security feature disabled */
1364         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1365 }
1366
1367 static int
1368 ut_setup_security(void)
1369 {
1370         /* Configure and start the device with no features disabled */
1371         return dev_configure_and_start(0);
1372 }
1373
1374 void
1375 ut_teardown(void)
1376 {
1377         struct crypto_testsuite_params *ts_params = &testsuite_params;
1378         struct crypto_unittest_params *ut_params = &unittest_params;
1379         struct rte_cryptodev_stats stats;
1380
1381         /* free crypto session structure */
1382 #ifdef RTE_LIB_SECURITY
1383         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1384                 if (ut_params->sec_session) {
1385                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1386                                                 (ts_params->valid_devs[0]),
1387                                                 ut_params->sec_session);
1388                         ut_params->sec_session = NULL;
1389                 }
1390         } else
1391 #endif
1392         {
1393                 if (ut_params->sess) {
1394                         rte_cryptodev_sym_session_clear(
1395                                         ts_params->valid_devs[0],
1396                                         ut_params->sess);
1397                         rte_cryptodev_sym_session_free(ut_params->sess);
1398                         ut_params->sess = NULL;
1399                 }
1400         }
1401
1402         /* free crypto operation structure */
1403         if (ut_params->op)
1404                 rte_crypto_op_free(ut_params->op);
1405
1406         /*
1407          * free mbuf - both obuf and ibuf are usually the same,
1408          * so check if they point at the same address is necessary,
1409          * to avoid freeing the mbuf twice.
1410          */
1411         if (ut_params->obuf) {
1412                 rte_pktmbuf_free(ut_params->obuf);
1413                 if (ut_params->ibuf == ut_params->obuf)
1414                         ut_params->ibuf = 0;
1415                 ut_params->obuf = 0;
1416         }
1417         if (ut_params->ibuf) {
1418                 rte_pktmbuf_free(ut_params->ibuf);
1419                 ut_params->ibuf = 0;
1420         }
1421
1422         if (ts_params->mbuf_pool != NULL)
1423                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1424                         rte_mempool_avail_count(ts_params->mbuf_pool));
1425
1426         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
1427
1428         /* Stop the device */
1429         rte_cryptodev_stop(ts_params->valid_devs[0]);
1430 }
1431
1432 static int
1433 test_device_configure_invalid_dev_id(void)
1434 {
1435         struct crypto_testsuite_params *ts_params = &testsuite_params;
1436         uint16_t dev_id, num_devs = 0;
1437
1438         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1439                         "Need at least %d devices for test", 1);
1440
1441         /* valid dev_id values */
1442         dev_id = ts_params->valid_devs[0];
1443
1444         /* Stop the device in case it's started so it can be configured */
1445         rte_cryptodev_stop(dev_id);
1446
1447         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1448                         "Failed test for rte_cryptodev_configure: "
1449                         "invalid dev_num %u", dev_id);
1450
1451         /* invalid dev_id values */
1452         dev_id = num_devs;
1453
1454         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1455                         "Failed test for rte_cryptodev_configure: "
1456                         "invalid dev_num %u", dev_id);
1457
1458         dev_id = 0xff;
1459
1460         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1461                         "Failed test for rte_cryptodev_configure:"
1462                         "invalid dev_num %u", dev_id);
1463
1464         return TEST_SUCCESS;
1465 }
1466
1467 static int
1468 test_device_configure_invalid_queue_pair_ids(void)
1469 {
1470         struct crypto_testsuite_params *ts_params = &testsuite_params;
1471         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1472
1473         /* Stop the device in case it's started so it can be configured */
1474         rte_cryptodev_stop(ts_params->valid_devs[0]);
1475
1476         /* valid - max value queue pairs */
1477         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1478
1479         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1480                         &ts_params->conf),
1481                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1482                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1483
1484         /* valid - one queue pairs */
1485         ts_params->conf.nb_queue_pairs = 1;
1486
1487         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1488                         &ts_params->conf),
1489                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1490                         ts_params->valid_devs[0],
1491                         ts_params->conf.nb_queue_pairs);
1492
1493
1494         /* invalid - zero queue pairs */
1495         ts_params->conf.nb_queue_pairs = 0;
1496
1497         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1498                         &ts_params->conf),
1499                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1500                         " invalid qps: %u",
1501                         ts_params->valid_devs[0],
1502                         ts_params->conf.nb_queue_pairs);
1503
1504
1505         /* invalid - max value supported by field queue pairs */
1506         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1507
1508         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1509                         &ts_params->conf),
1510                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1511                         " invalid qps: %u",
1512                         ts_params->valid_devs[0],
1513                         ts_params->conf.nb_queue_pairs);
1514
1515
1516         /* invalid - max value + 1 queue pairs */
1517         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1518
1519         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1520                         &ts_params->conf),
1521                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1522                         " invalid qps: %u",
1523                         ts_params->valid_devs[0],
1524                         ts_params->conf.nb_queue_pairs);
1525
1526         /* revert to original testsuite value */
1527         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1528
1529         return TEST_SUCCESS;
1530 }
1531
1532 static int
1533 test_queue_pair_descriptor_setup(void)
1534 {
1535         struct crypto_testsuite_params *ts_params = &testsuite_params;
1536         struct rte_cryptodev_qp_conf qp_conf = {
1537                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1538         };
1539         uint16_t qp_id;
1540
1541         /* Stop the device in case it's started so it can be configured */
1542         rte_cryptodev_stop(ts_params->valid_devs[0]);
1543
1544         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1545                         &ts_params->conf),
1546                         "Failed to configure cryptodev %u",
1547                         ts_params->valid_devs[0]);
1548
1549         /*
1550          * Test various ring sizes on this device. memzones can't be
1551          * freed so are re-used if ring is released and re-created.
1552          */
1553         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1554         qp_conf.mp_session = ts_params->session_mpool;
1555         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1556
1557         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1558                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1559                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1560                                 rte_cryptodev_socket_id(
1561                                                 ts_params->valid_devs[0])),
1562                                 "Failed test for "
1563                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1564                                 "%u on qp %u on cryptodev %u",
1565                                 qp_conf.nb_descriptors, qp_id,
1566                                 ts_params->valid_devs[0]);
1567         }
1568
1569         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1570
1571         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1572                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1573                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1574                                 rte_cryptodev_socket_id(
1575                                                 ts_params->valid_devs[0])),
1576                                 "Failed test for"
1577                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1578                                 " %u on qp %u on cryptodev %u",
1579                                 qp_conf.nb_descriptors, qp_id,
1580                                 ts_params->valid_devs[0]);
1581         }
1582
1583         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1584
1585         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1586                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1587                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1588                                 rte_cryptodev_socket_id(
1589                                                 ts_params->valid_devs[0])),
1590                                 "Failed test for "
1591                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1592                                 " %u on qp %u on cryptodev %u",
1593                                 qp_conf.nb_descriptors, qp_id,
1594                                 ts_params->valid_devs[0]);
1595         }
1596
1597         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1598
1599         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1600                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1601                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1602                                 rte_cryptodev_socket_id(
1603                                                 ts_params->valid_devs[0])),
1604                                 "Failed test for"
1605                                 " rte_cryptodev_queue_pair_setup:"
1606                                 "num_inflights %u on qp %u on cryptodev %u",
1607                                 qp_conf.nb_descriptors, qp_id,
1608                                 ts_params->valid_devs[0]);
1609         }
1610
1611         /* test invalid queue pair id */
1612         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1613
1614         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1615
1616         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1617                         ts_params->valid_devs[0],
1618                         qp_id, &qp_conf,
1619                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1620                         "Failed test for rte_cryptodev_queue_pair_setup:"
1621                         "invalid qp %u on cryptodev %u",
1622                         qp_id, ts_params->valid_devs[0]);
1623
1624         qp_id = 0xffff; /*invalid*/
1625
1626         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1627                         ts_params->valid_devs[0],
1628                         qp_id, &qp_conf,
1629                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1630                         "Failed test for rte_cryptodev_queue_pair_setup:"
1631                         "invalid qp %u on cryptodev %u",
1632                         qp_id, ts_params->valid_devs[0]);
1633
1634         return TEST_SUCCESS;
1635 }
1636
1637 /* ***** Plaintext data for tests ***** */
1638
1639 const char catch_22_quote_1[] =
1640                 "There was only one catch and that was Catch-22, which "
1641                 "specified that a concern for one's safety in the face of "
1642                 "dangers that were real and immediate was the process of a "
1643                 "rational mind. Orr was crazy and could be grounded. All he "
1644                 "had to do was ask; and as soon as he did, he would no longer "
1645                 "be crazy and would have to fly more missions. Orr would be "
1646                 "crazy to fly more missions and sane if he didn't, but if he "
1647                 "was sane he had to fly them. If he flew them he was crazy "
1648                 "and didn't have to; but if he didn't want to he was sane and "
1649                 "had to. Yossarian was moved very deeply by the absolute "
1650                 "simplicity of this clause of Catch-22 and let out a "
1651                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1652                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1653
1654 const char catch_22_quote[] =
1655                 "What a lousy earth! He wondered how many people were "
1656                 "destitute that same night even in his own prosperous country, "
1657                 "how many homes were shanties, how many husbands were drunk "
1658                 "and wives socked, and how many children were bullied, abused, "
1659                 "or abandoned. How many families hungered for food they could "
1660                 "not afford to buy? How many hearts were broken? How many "
1661                 "suicides would take place that same night, how many people "
1662                 "would go insane? How many cockroaches and landlords would "
1663                 "triumph? How many winners were losers, successes failures, "
1664                 "and rich men poor men? How many wise guys were stupid? How "
1665                 "many happy endings were unhappy endings? How many honest men "
1666                 "were liars, brave men cowards, loyal men traitors, how many "
1667                 "sainted men were corrupt, how many people in positions of "
1668                 "trust had sold their souls to bodyguards, how many had never "
1669                 "had souls? How many straight-and-narrow paths were crooked "
1670                 "paths? How many best families were worst families and how "
1671                 "many good people were bad people? When you added them all up "
1672                 "and then subtracted, you might be left with only the children, "
1673                 "and perhaps with Albert Einstein and an old violinist or "
1674                 "sculptor somewhere.";
1675
1676 #define QUOTE_480_BYTES         (480)
1677 #define QUOTE_512_BYTES         (512)
1678 #define QUOTE_768_BYTES         (768)
1679 #define QUOTE_1024_BYTES        (1024)
1680
1681
1682
1683 /* ***** SHA1 Hash Tests ***** */
1684
1685 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1686
1687 static uint8_t hmac_sha1_key[] = {
1688         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1689         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1690         0xDE, 0xF4, 0xDE, 0xAD };
1691
1692 /* ***** SHA224 Hash Tests ***** */
1693
1694 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1695
1696
1697 /* ***** AES-CBC Cipher Tests ***** */
1698
1699 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1700 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1701
1702 static uint8_t aes_cbc_key[] = {
1703         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1704         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1705
1706 static uint8_t aes_cbc_iv[] = {
1707         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1708         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1709
1710
1711 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1712
1713 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1714         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1715         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1716         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1717         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1718         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1719         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1720         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1721         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1722         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1723         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1724         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1725         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1726         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1727         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1728         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1729         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1730         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1731         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1732         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1733         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1734         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1735         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1736         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1737         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1738         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1739         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1740         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1741         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1742         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1743         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1744         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1745         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1746         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1747         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1748         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1749         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1750         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1751         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1752         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1753         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1754         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1755         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1756         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1757         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1758         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1759         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1760         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1761         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1762         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1763         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1764         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1765         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1766         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1767         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1768         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1769         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1770         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1771         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1772         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1773         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1774         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1775         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1776         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1777         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1778 };
1779
1780 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1781         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1782         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1783         0x18, 0x8c, 0x1d, 0x32
1784 };
1785
1786
1787 /* Multisession Vector context Test */
1788 /*Begin Session 0 */
1789 static uint8_t ms_aes_cbc_key0[] = {
1790         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1791         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1792 };
1793
1794 static uint8_t ms_aes_cbc_iv0[] = {
1795         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1796         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1797 };
1798
1799 static const uint8_t ms_aes_cbc_cipher0[] = {
1800                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1801                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1802                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1803                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1804                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1805                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1806                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1807                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1808                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1809                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1810                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1811                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1812                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1813                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1814                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1815                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1816                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1817                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1818                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1819                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1820                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1821                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1822                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1823                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1824                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1825                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1826                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1827                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1828                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1829                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1830                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1831                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1832                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1833                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1834                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1835                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1836                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1837                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1838                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1839                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1840                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1841                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1842                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1843                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1844                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1845                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1846                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1847                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1848                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1849                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1850                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1851                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1852                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1853                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1854                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1855                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1856                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1857                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1858                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1859                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1860                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1861                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1862                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1863                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1864 };
1865
1866
1867 static  uint8_t ms_hmac_key0[] = {
1868                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1869                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1870                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1871                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1872                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1873                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1874                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1875                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1876 };
1877
1878 static const uint8_t ms_hmac_digest0[] = {
1879                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1880                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1881                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1882                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1883                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1884                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1885                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1886                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1887                 };
1888
1889 /* End Session 0 */
1890 /* Begin session 1 */
1891
1892 static  uint8_t ms_aes_cbc_key1[] = {
1893                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1894                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1895 };
1896
1897 static  uint8_t ms_aes_cbc_iv1[] = {
1898         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1899         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1900 };
1901
1902 static const uint8_t ms_aes_cbc_cipher1[] = {
1903                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1904                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1905                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1906                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1907                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1908                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1909                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1910                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1911                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1912                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1913                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1914                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1915                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1916                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1917                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1918                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1919                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1920                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1921                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1922                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1923                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1924                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1925                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1926                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1927                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1928                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1929                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1930                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1931                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1932                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1933                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1934                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1935                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1936                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1937                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1938                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1939                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1940                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1941                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1942                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1943                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1944                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1945                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1946                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1947                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1948                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1949                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1950                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1951                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1952                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1953                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1954                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1955                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1956                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1957                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1958                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1959                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1960                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1961                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1962                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1963                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1964                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1965                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1966                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1967
1968 };
1969
1970 static uint8_t ms_hmac_key1[] = {
1971                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1972                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1973                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1974                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1975                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1976                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1977                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1978                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1979 };
1980
1981 static const uint8_t ms_hmac_digest1[] = {
1982                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1983                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1984                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1985                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1986                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1987                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1988                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1989                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1990 };
1991 /* End Session 1  */
1992 /* Begin Session 2 */
1993 static  uint8_t ms_aes_cbc_key2[] = {
1994                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1995                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1996 };
1997
1998 static  uint8_t ms_aes_cbc_iv2[] = {
1999                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2000                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2001 };
2002
2003 static const uint8_t ms_aes_cbc_cipher2[] = {
2004                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2005                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2006                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2007                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2008                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2009                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2010                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2011                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2012                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2013                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2014                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2015                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2016                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2017                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2018                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2019                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2020                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2021                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2022                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2023                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2024                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2025                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2026                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2027                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2028                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2029                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2030                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2031                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2032                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2033                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2034                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2035                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2036                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2037                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2038                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2039                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2040                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2041                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2042                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2043                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2044                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2045                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2046                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2047                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2048                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2049                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2050                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2051                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2052                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2053                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2054                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2055                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2056                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2057                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2058                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2059                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2060                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2061                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2062                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2063                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2064                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2065                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2066                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2067                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2068 };
2069
2070 static  uint8_t ms_hmac_key2[] = {
2071                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2072                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2073                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2074                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2075                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2076                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2077                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2078                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2079 };
2080
2081 static const uint8_t ms_hmac_digest2[] = {
2082                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2083                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2084                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2085                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2086                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2087                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2088                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2089                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2090 };
2091
2092 /* End Session 2 */
2093
2094
2095 static int
2096 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2097 {
2098         struct crypto_testsuite_params *ts_params = &testsuite_params;
2099         struct crypto_unittest_params *ut_params = &unittest_params;
2100
2101         /* Verify the capabilities */
2102         struct rte_cryptodev_sym_capability_idx cap_idx;
2103         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2104         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2105         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2106                         &cap_idx) == NULL)
2107                 return TEST_SKIPPED;
2108         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2109         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2110         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2111                         &cap_idx) == NULL)
2112                 return TEST_SKIPPED;
2113
2114         /* Generate test mbuf data and space for digest */
2115         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2116                         catch_22_quote, QUOTE_512_BYTES, 0);
2117
2118         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2119                         DIGEST_BYTE_LENGTH_SHA1);
2120         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2121
2122         /* Setup Cipher Parameters */
2123         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2124         ut_params->cipher_xform.next = &ut_params->auth_xform;
2125
2126         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2127         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2128         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2129         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2130         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2131         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2132
2133         /* Setup HMAC Parameters */
2134         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2135
2136         ut_params->auth_xform.next = NULL;
2137
2138         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2139         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2140         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2141         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2142         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2143
2144         ut_params->sess = rte_cryptodev_sym_session_create(
2145                         ts_params->session_mpool);
2146
2147         /* Create crypto session*/
2148         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2149                         ut_params->sess, &ut_params->cipher_xform,
2150                         ts_params->session_priv_mpool);
2151         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2152
2153         /* Generate crypto op data structure */
2154         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2155                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2156         TEST_ASSERT_NOT_NULL(ut_params->op,
2157                         "Failed to allocate symmetric crypto operation struct");
2158
2159         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2160
2161         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2162
2163         /* set crypto operation source mbuf */
2164         sym_op->m_src = ut_params->ibuf;
2165
2166         /* Set crypto operation authentication parameters */
2167         sym_op->auth.digest.data = ut_params->digest;
2168         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2169                         ut_params->ibuf, QUOTE_512_BYTES);
2170
2171         sym_op->auth.data.offset = 0;
2172         sym_op->auth.data.length = QUOTE_512_BYTES;
2173
2174         /* Copy IV at the end of the crypto operation */
2175         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2176                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2177
2178         /* Set crypto operation cipher parameters */
2179         sym_op->cipher.data.offset = 0;
2180         sym_op->cipher.data.length = QUOTE_512_BYTES;
2181
2182         /* Process crypto operation */
2183         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2184                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2185                         ut_params->op);
2186         else
2187                 TEST_ASSERT_NOT_NULL(
2188                         process_crypto_request(ts_params->valid_devs[0],
2189                                 ut_params->op),
2190                                 "failed to process sym crypto op");
2191
2192         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2193                         "crypto op processing failed");
2194
2195         /* Validate obuf */
2196         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2197                         uint8_t *);
2198
2199         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2200                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2201                         QUOTE_512_BYTES,
2202                         "ciphertext data not as expected");
2203
2204         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2205
2206         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2207                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2208                         gbl_driver_id == rte_cryptodev_driver_id_get(
2209                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2210                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2211                                         DIGEST_BYTE_LENGTH_SHA1,
2212                         "Generated digest data not as expected");
2213
2214         return TEST_SUCCESS;
2215 }
2216
2217 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2218
2219 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2220
2221 static uint8_t hmac_sha512_key[] = {
2222         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2223         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2224         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2225         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2226         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2227         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2228         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2229         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2230
2231 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2232         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2233         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2234         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2235         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2236         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2237         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2238         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2239         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2240
2241
2242
2243 static int
2244 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2245                 struct crypto_unittest_params *ut_params,
2246                 uint8_t *cipher_key,
2247                 uint8_t *hmac_key);
2248
2249 static int
2250 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2251                 struct crypto_unittest_params *ut_params,
2252                 struct crypto_testsuite_params *ts_params,
2253                 const uint8_t *cipher,
2254                 const uint8_t *digest,
2255                 const uint8_t *iv);
2256
2257
2258 static int
2259 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2260                 struct crypto_unittest_params *ut_params,
2261                 uint8_t *cipher_key,
2262                 uint8_t *hmac_key)
2263 {
2264
2265         /* Setup Cipher Parameters */
2266         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2267         ut_params->cipher_xform.next = NULL;
2268
2269         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2270         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2271         ut_params->cipher_xform.cipher.key.data = cipher_key;
2272         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2273         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2274         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2275
2276         /* Setup HMAC Parameters */
2277         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2278         ut_params->auth_xform.next = &ut_params->cipher_xform;
2279
2280         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2281         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2282         ut_params->auth_xform.auth.key.data = hmac_key;
2283         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2284         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2285
2286         return TEST_SUCCESS;
2287 }
2288
2289
2290 static int
2291 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2292                 struct crypto_unittest_params *ut_params,
2293                 struct crypto_testsuite_params *ts_params,
2294                 const uint8_t *cipher,
2295                 const uint8_t *digest,
2296                 const uint8_t *iv)
2297 {
2298         /* Generate test mbuf data and digest */
2299         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2300                         (const char *)
2301                         cipher,
2302                         QUOTE_512_BYTES, 0);
2303
2304         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2305                         DIGEST_BYTE_LENGTH_SHA512);
2306         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2307
2308         rte_memcpy(ut_params->digest,
2309                         digest,
2310                         DIGEST_BYTE_LENGTH_SHA512);
2311
2312         /* Generate Crypto op data structure */
2313         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2314                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2315         TEST_ASSERT_NOT_NULL(ut_params->op,
2316                         "Failed to allocate symmetric crypto operation struct");
2317
2318         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2319
2320         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2321
2322         /* set crypto operation source mbuf */
2323         sym_op->m_src = ut_params->ibuf;
2324
2325         sym_op->auth.digest.data = ut_params->digest;
2326         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2327                         ut_params->ibuf, QUOTE_512_BYTES);
2328
2329         sym_op->auth.data.offset = 0;
2330         sym_op->auth.data.length = QUOTE_512_BYTES;
2331
2332         /* Copy IV at the end of the crypto operation */
2333         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2334                         iv, CIPHER_IV_LENGTH_AES_CBC);
2335
2336         sym_op->cipher.data.offset = 0;
2337         sym_op->cipher.data.length = QUOTE_512_BYTES;
2338
2339         /* Process crypto operation */
2340         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2341                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2342                         ut_params->op);
2343         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2344                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2345                                 ut_params->op, 1, 1, 0, 0);
2346         else
2347                 TEST_ASSERT_NOT_NULL(
2348                                 process_crypto_request(ts_params->valid_devs[0],
2349                                         ut_params->op),
2350                                         "failed to process sym crypto op");
2351
2352         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2353                         "crypto op processing failed");
2354
2355         ut_params->obuf = ut_params->op->sym->m_src;
2356
2357         /* Validate obuf */
2358         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2359                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2360                         catch_22_quote,
2361                         QUOTE_512_BYTES,
2362                         "Plaintext data not as expected");
2363
2364         /* Validate obuf */
2365         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2366                         "Digest verification failed");
2367
2368         return TEST_SUCCESS;
2369 }
2370
2371 /* ***** SNOW 3G Tests ***** */
2372 static int
2373 create_wireless_algo_hash_session(uint8_t dev_id,
2374         const uint8_t *key, const uint8_t key_len,
2375         const uint8_t iv_len, const uint8_t auth_len,
2376         enum rte_crypto_auth_operation op,
2377         enum rte_crypto_auth_algorithm algo)
2378 {
2379         uint8_t hash_key[key_len];
2380         int status;
2381
2382         struct crypto_testsuite_params *ts_params = &testsuite_params;
2383         struct crypto_unittest_params *ut_params = &unittest_params;
2384
2385         memcpy(hash_key, key, key_len);
2386
2387         debug_hexdump(stdout, "key:", key, key_len);
2388
2389         /* Setup Authentication Parameters */
2390         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2391         ut_params->auth_xform.next = NULL;
2392
2393         ut_params->auth_xform.auth.op = op;
2394         ut_params->auth_xform.auth.algo = algo;
2395         ut_params->auth_xform.auth.key.length = key_len;
2396         ut_params->auth_xform.auth.key.data = hash_key;
2397         ut_params->auth_xform.auth.digest_length = auth_len;
2398         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2399         ut_params->auth_xform.auth.iv.length = iv_len;
2400         ut_params->sess = rte_cryptodev_sym_session_create(
2401                         ts_params->session_mpool);
2402
2403         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2404                         &ut_params->auth_xform,
2405                         ts_params->session_priv_mpool);
2406         if (status == -ENOTSUP)
2407                 return TEST_SKIPPED;
2408
2409         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2410         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2411         return 0;
2412 }
2413
2414 static int
2415 create_wireless_algo_cipher_session(uint8_t dev_id,
2416                         enum rte_crypto_cipher_operation op,
2417                         enum rte_crypto_cipher_algorithm algo,
2418                         const uint8_t *key, const uint8_t key_len,
2419                         uint8_t iv_len)
2420 {
2421         uint8_t cipher_key[key_len];
2422         int status;
2423         struct crypto_testsuite_params *ts_params = &testsuite_params;
2424         struct crypto_unittest_params *ut_params = &unittest_params;
2425
2426         memcpy(cipher_key, key, key_len);
2427
2428         /* Setup Cipher Parameters */
2429         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2430         ut_params->cipher_xform.next = NULL;
2431
2432         ut_params->cipher_xform.cipher.algo = algo;
2433         ut_params->cipher_xform.cipher.op = op;
2434         ut_params->cipher_xform.cipher.key.data = cipher_key;
2435         ut_params->cipher_xform.cipher.key.length = key_len;
2436         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2437         ut_params->cipher_xform.cipher.iv.length = iv_len;
2438
2439         debug_hexdump(stdout, "key:", key, key_len);
2440
2441         /* Create Crypto session */
2442         ut_params->sess = rte_cryptodev_sym_session_create(
2443                         ts_params->session_mpool);
2444
2445         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2446                         &ut_params->cipher_xform,
2447                         ts_params->session_priv_mpool);
2448         if (status == -ENOTSUP)
2449                 return TEST_SKIPPED;
2450
2451         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2452         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2453         return 0;
2454 }
2455
2456 static int
2457 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2458                         unsigned int cipher_len,
2459                         unsigned int cipher_offset)
2460 {
2461         struct crypto_testsuite_params *ts_params = &testsuite_params;
2462         struct crypto_unittest_params *ut_params = &unittest_params;
2463
2464         /* Generate Crypto op data structure */
2465         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2466                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2467         TEST_ASSERT_NOT_NULL(ut_params->op,
2468                                 "Failed to allocate pktmbuf offload");
2469
2470         /* Set crypto operation data parameters */
2471         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2472
2473         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2474
2475         /* set crypto operation source mbuf */
2476         sym_op->m_src = ut_params->ibuf;
2477
2478         /* iv */
2479         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2480                         iv, iv_len);
2481         sym_op->cipher.data.length = cipher_len;
2482         sym_op->cipher.data.offset = cipher_offset;
2483         return 0;
2484 }
2485
2486 static int
2487 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2488                         unsigned int cipher_len,
2489                         unsigned int cipher_offset)
2490 {
2491         struct crypto_testsuite_params *ts_params = &testsuite_params;
2492         struct crypto_unittest_params *ut_params = &unittest_params;
2493
2494         /* Generate Crypto op data structure */
2495         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2496                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2497         TEST_ASSERT_NOT_NULL(ut_params->op,
2498                                 "Failed to allocate pktmbuf offload");
2499
2500         /* Set crypto operation data parameters */
2501         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2502
2503         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2504
2505         /* set crypto operation source mbuf */
2506         sym_op->m_src = ut_params->ibuf;
2507         sym_op->m_dst = ut_params->obuf;
2508
2509         /* iv */
2510         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2511                         iv, iv_len);
2512         sym_op->cipher.data.length = cipher_len;
2513         sym_op->cipher.data.offset = cipher_offset;
2514         return 0;
2515 }
2516
2517 static int
2518 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2519                 enum rte_crypto_cipher_operation cipher_op,
2520                 enum rte_crypto_auth_operation auth_op,
2521                 enum rte_crypto_auth_algorithm auth_algo,
2522                 enum rte_crypto_cipher_algorithm cipher_algo,
2523                 const uint8_t *key, uint8_t key_len,
2524                 uint8_t auth_iv_len, uint8_t auth_len,
2525                 uint8_t cipher_iv_len)
2526
2527 {
2528         uint8_t cipher_auth_key[key_len];
2529         int status;
2530
2531         struct crypto_testsuite_params *ts_params = &testsuite_params;
2532         struct crypto_unittest_params *ut_params = &unittest_params;
2533
2534         memcpy(cipher_auth_key, key, key_len);
2535
2536         /* Setup Authentication Parameters */
2537         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2538         ut_params->auth_xform.next = NULL;
2539
2540         ut_params->auth_xform.auth.op = auth_op;
2541         ut_params->auth_xform.auth.algo = auth_algo;
2542         ut_params->auth_xform.auth.key.length = key_len;
2543         /* Hash key = cipher key */
2544         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2545         ut_params->auth_xform.auth.digest_length = auth_len;
2546         /* Auth IV will be after cipher IV */
2547         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2548         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2549
2550         /* Setup Cipher Parameters */
2551         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2552         ut_params->cipher_xform.next = &ut_params->auth_xform;
2553
2554         ut_params->cipher_xform.cipher.algo = cipher_algo;
2555         ut_params->cipher_xform.cipher.op = cipher_op;
2556         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2557         ut_params->cipher_xform.cipher.key.length = key_len;
2558         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2559         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2560
2561         debug_hexdump(stdout, "key:", key, key_len);
2562
2563         /* Create Crypto session*/
2564         ut_params->sess = rte_cryptodev_sym_session_create(
2565                         ts_params->session_mpool);
2566         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2567
2568         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2569                         &ut_params->cipher_xform,
2570                         ts_params->session_priv_mpool);
2571         if (status == -ENOTSUP)
2572                 return TEST_SKIPPED;
2573
2574         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2575         return 0;
2576 }
2577
2578 static int
2579 create_wireless_cipher_auth_session(uint8_t dev_id,
2580                 enum rte_crypto_cipher_operation cipher_op,
2581                 enum rte_crypto_auth_operation auth_op,
2582                 enum rte_crypto_auth_algorithm auth_algo,
2583                 enum rte_crypto_cipher_algorithm cipher_algo,
2584                 const struct wireless_test_data *tdata)
2585 {
2586         const uint8_t key_len = tdata->key.len;
2587         uint8_t cipher_auth_key[key_len];
2588         int status;
2589
2590         struct crypto_testsuite_params *ts_params = &testsuite_params;
2591         struct crypto_unittest_params *ut_params = &unittest_params;
2592         const uint8_t *key = tdata->key.data;
2593         const uint8_t auth_len = tdata->digest.len;
2594         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2595         uint8_t auth_iv_len = tdata->auth_iv.len;
2596
2597         memcpy(cipher_auth_key, key, key_len);
2598
2599         /* Setup Authentication Parameters */
2600         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2601         ut_params->auth_xform.next = NULL;
2602
2603         ut_params->auth_xform.auth.op = auth_op;
2604         ut_params->auth_xform.auth.algo = auth_algo;
2605         ut_params->auth_xform.auth.key.length = key_len;
2606         /* Hash key = cipher key */
2607         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2608         ut_params->auth_xform.auth.digest_length = auth_len;
2609         /* Auth IV will be after cipher IV */
2610         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2611         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2612
2613         /* Setup Cipher Parameters */
2614         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2615         ut_params->cipher_xform.next = &ut_params->auth_xform;
2616
2617         ut_params->cipher_xform.cipher.algo = cipher_algo;
2618         ut_params->cipher_xform.cipher.op = cipher_op;
2619         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2620         ut_params->cipher_xform.cipher.key.length = key_len;
2621         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2622         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2623
2624
2625         debug_hexdump(stdout, "key:", key, key_len);
2626
2627         /* Create Crypto session*/
2628         ut_params->sess = rte_cryptodev_sym_session_create(
2629                         ts_params->session_mpool);
2630
2631         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2632                         &ut_params->cipher_xform,
2633                         ts_params->session_priv_mpool);
2634         if (status == -ENOTSUP)
2635                 return TEST_SKIPPED;
2636
2637         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2638         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2639         return 0;
2640 }
2641
2642 static int
2643 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2644                 const struct wireless_test_data *tdata)
2645 {
2646         return create_wireless_cipher_auth_session(dev_id,
2647                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2648                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2649                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2650 }
2651
2652 static int
2653 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2654                 enum rte_crypto_cipher_operation cipher_op,
2655                 enum rte_crypto_auth_operation auth_op,
2656                 enum rte_crypto_auth_algorithm auth_algo,
2657                 enum rte_crypto_cipher_algorithm cipher_algo,
2658                 const uint8_t *key, const uint8_t key_len,
2659                 uint8_t auth_iv_len, uint8_t auth_len,
2660                 uint8_t cipher_iv_len)
2661 {
2662         uint8_t auth_cipher_key[key_len];
2663         int status;
2664         struct crypto_testsuite_params *ts_params = &testsuite_params;
2665         struct crypto_unittest_params *ut_params = &unittest_params;
2666
2667         memcpy(auth_cipher_key, key, key_len);
2668
2669         /* Setup Authentication Parameters */
2670         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2671         ut_params->auth_xform.auth.op = auth_op;
2672         ut_params->auth_xform.next = &ut_params->cipher_xform;
2673         ut_params->auth_xform.auth.algo = auth_algo;
2674         ut_params->auth_xform.auth.key.length = key_len;
2675         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2676         ut_params->auth_xform.auth.digest_length = auth_len;
2677         /* Auth IV will be after cipher IV */
2678         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2679         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2680
2681         /* Setup Cipher Parameters */
2682         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2683         ut_params->cipher_xform.next = NULL;
2684         ut_params->cipher_xform.cipher.algo = cipher_algo;
2685         ut_params->cipher_xform.cipher.op = cipher_op;
2686         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2687         ut_params->cipher_xform.cipher.key.length = key_len;
2688         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2689         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2690
2691         debug_hexdump(stdout, "key:", key, key_len);
2692
2693         /* Create Crypto session*/
2694         ut_params->sess = rte_cryptodev_sym_session_create(
2695                         ts_params->session_mpool);
2696         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2697
2698         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2699                 ut_params->auth_xform.next = NULL;
2700                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2701                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2702                                 &ut_params->cipher_xform,
2703                                 ts_params->session_priv_mpool);
2704
2705         } else
2706                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2707                                 &ut_params->auth_xform,
2708                                 ts_params->session_priv_mpool);
2709
2710         if (status == -ENOTSUP)
2711                 return TEST_SKIPPED;
2712
2713         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2714
2715         return 0;
2716 }
2717
2718 static int
2719 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2720                 unsigned int auth_tag_len,
2721                 const uint8_t *iv, unsigned int iv_len,
2722                 unsigned int data_pad_len,
2723                 enum rte_crypto_auth_operation op,
2724                 unsigned int auth_len, unsigned int auth_offset)
2725 {
2726         struct crypto_testsuite_params *ts_params = &testsuite_params;
2727
2728         struct crypto_unittest_params *ut_params = &unittest_params;
2729
2730         /* Generate Crypto op data structure */
2731         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2732                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2733         TEST_ASSERT_NOT_NULL(ut_params->op,
2734                 "Failed to allocate pktmbuf offload");
2735
2736         /* Set crypto operation data parameters */
2737         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2738
2739         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2740
2741         /* set crypto operation source mbuf */
2742         sym_op->m_src = ut_params->ibuf;
2743
2744         /* iv */
2745         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2746                         iv, iv_len);
2747         /* digest */
2748         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2749                                         ut_params->ibuf, auth_tag_len);
2750
2751         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2752                                 "no room to append auth tag");
2753         ut_params->digest = sym_op->auth.digest.data;
2754         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2755                         ut_params->ibuf, data_pad_len);
2756         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2757                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2758         else
2759                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2760
2761         debug_hexdump(stdout, "digest:",
2762                 sym_op->auth.digest.data,
2763                 auth_tag_len);
2764
2765         sym_op->auth.data.length = auth_len;
2766         sym_op->auth.data.offset = auth_offset;
2767
2768         return 0;
2769 }
2770
2771 static int
2772 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2773         enum rte_crypto_auth_operation op)
2774 {
2775         struct crypto_testsuite_params *ts_params = &testsuite_params;
2776         struct crypto_unittest_params *ut_params = &unittest_params;
2777
2778         const uint8_t *auth_tag = tdata->digest.data;
2779         const unsigned int auth_tag_len = tdata->digest.len;
2780         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2781         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2782
2783         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2784         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2785         const uint8_t *auth_iv = tdata->auth_iv.data;
2786         const uint8_t auth_iv_len = tdata->auth_iv.len;
2787         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2788         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2789
2790         /* Generate Crypto op data structure */
2791         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2792                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2793         TEST_ASSERT_NOT_NULL(ut_params->op,
2794                         "Failed to allocate pktmbuf offload");
2795         /* Set crypto operation data parameters */
2796         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2797
2798         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2799
2800         /* set crypto operation source mbuf */
2801         sym_op->m_src = ut_params->ibuf;
2802
2803         /* digest */
2804         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2805                         ut_params->ibuf, auth_tag_len);
2806
2807         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2808                         "no room to append auth tag");
2809         ut_params->digest = sym_op->auth.digest.data;
2810         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2811                         ut_params->ibuf, data_pad_len);
2812         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2813                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2814         else
2815                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2816
2817         debug_hexdump(stdout, "digest:",
2818                 sym_op->auth.digest.data,
2819                 auth_tag_len);
2820
2821         /* Copy cipher and auth IVs at the end of the crypto operation */
2822         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2823                                                 IV_OFFSET);
2824         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2825         iv_ptr += cipher_iv_len;
2826         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2827
2828         sym_op->cipher.data.length = cipher_len;
2829         sym_op->cipher.data.offset = 0;
2830         sym_op->auth.data.length = auth_len;
2831         sym_op->auth.data.offset = 0;
2832
2833         return 0;
2834 }
2835
2836 static int
2837 create_zuc_cipher_hash_generate_operation(
2838                 const struct wireless_test_data *tdata)
2839 {
2840         return create_wireless_cipher_hash_operation(tdata,
2841                 RTE_CRYPTO_AUTH_OP_GENERATE);
2842 }
2843
2844 static int
2845 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2846                 const unsigned auth_tag_len,
2847                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2848                 unsigned data_pad_len,
2849                 enum rte_crypto_auth_operation op,
2850                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2851                 const unsigned cipher_len, const unsigned cipher_offset,
2852                 const unsigned auth_len, const unsigned auth_offset)
2853 {
2854         struct crypto_testsuite_params *ts_params = &testsuite_params;
2855         struct crypto_unittest_params *ut_params = &unittest_params;
2856
2857         enum rte_crypto_cipher_algorithm cipher_algo =
2858                         ut_params->cipher_xform.cipher.algo;
2859         enum rte_crypto_auth_algorithm auth_algo =
2860                         ut_params->auth_xform.auth.algo;
2861
2862         /* Generate Crypto op data structure */
2863         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2864                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2865         TEST_ASSERT_NOT_NULL(ut_params->op,
2866                         "Failed to allocate pktmbuf offload");
2867         /* Set crypto operation data parameters */
2868         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2869
2870         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2871
2872         /* set crypto operation source mbuf */
2873         sym_op->m_src = ut_params->ibuf;
2874
2875         /* digest */
2876         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2877                         ut_params->ibuf, auth_tag_len);
2878
2879         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2880                         "no room to append auth tag");
2881         ut_params->digest = sym_op->auth.digest.data;
2882
2883         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2884                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2885                                 ut_params->ibuf, data_pad_len);
2886         } else {
2887                 struct rte_mbuf *m = ut_params->ibuf;
2888                 unsigned int offset = data_pad_len;
2889
2890                 while (offset > m->data_len && m->next != NULL) {
2891                         offset -= m->data_len;
2892                         m = m->next;
2893                 }
2894                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2895                         m, offset);
2896         }
2897
2898         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2899                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2900         else
2901                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2902
2903         debug_hexdump(stdout, "digest:",
2904                 sym_op->auth.digest.data,
2905                 auth_tag_len);
2906
2907         /* Copy cipher and auth IVs at the end of the crypto operation */
2908         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2909                                                 IV_OFFSET);
2910         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2911         iv_ptr += cipher_iv_len;
2912         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2913
2914         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2915                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2916                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2917                 sym_op->cipher.data.length = cipher_len;
2918                 sym_op->cipher.data.offset = cipher_offset;
2919         } else {
2920                 sym_op->cipher.data.length = cipher_len >> 3;
2921                 sym_op->cipher.data.offset = cipher_offset >> 3;
2922         }
2923
2924         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2925                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2926                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2927                 sym_op->auth.data.length = auth_len;
2928                 sym_op->auth.data.offset = auth_offset;
2929         } else {
2930                 sym_op->auth.data.length = auth_len >> 3;
2931                 sym_op->auth.data.offset = auth_offset >> 3;
2932         }
2933
2934         return 0;
2935 }
2936
2937 static int
2938 create_wireless_algo_auth_cipher_operation(
2939                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2940                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2941                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2942                 unsigned int data_pad_len,
2943                 unsigned int cipher_len, unsigned int cipher_offset,
2944                 unsigned int auth_len, unsigned int auth_offset,
2945                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2946 {
2947         struct crypto_testsuite_params *ts_params = &testsuite_params;
2948         struct crypto_unittest_params *ut_params = &unittest_params;
2949
2950         enum rte_crypto_cipher_algorithm cipher_algo =
2951                         ut_params->cipher_xform.cipher.algo;
2952         enum rte_crypto_auth_algorithm auth_algo =
2953                         ut_params->auth_xform.auth.algo;
2954
2955         /* Generate Crypto op data structure */
2956         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2957                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2958         TEST_ASSERT_NOT_NULL(ut_params->op,
2959                         "Failed to allocate pktmbuf offload");
2960
2961         /* Set crypto operation data parameters */
2962         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2963
2964         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2965
2966         /* set crypto operation mbufs */
2967         sym_op->m_src = ut_params->ibuf;
2968         if (op_mode == OUT_OF_PLACE)
2969                 sym_op->m_dst = ut_params->obuf;
2970
2971         /* digest */
2972         if (!do_sgl) {
2973                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2974                         (op_mode == IN_PLACE ?
2975                                 ut_params->ibuf : ut_params->obuf),
2976                         uint8_t *, data_pad_len);
2977                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2978                         (op_mode == IN_PLACE ?
2979                                 ut_params->ibuf : ut_params->obuf),
2980                         data_pad_len);
2981                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2982         } else {
2983                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2984                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2985                                 sym_op->m_src : sym_op->m_dst);
2986                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2987                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2988                         sgl_buf = sgl_buf->next;
2989                 }
2990                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2991                                 uint8_t *, remaining_off);
2992                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2993                                 remaining_off);
2994                 memset(sym_op->auth.digest.data, 0, remaining_off);
2995                 while (sgl_buf->next != NULL) {
2996                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2997                                 0, rte_pktmbuf_data_len(sgl_buf));
2998                         sgl_buf = sgl_buf->next;
2999                 }
3000         }
3001
3002         /* Copy digest for the verification */
3003         if (verify)
3004                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3005
3006         /* Copy cipher and auth IVs at the end of the crypto operation */
3007         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3008                         ut_params->op, uint8_t *, IV_OFFSET);
3009
3010         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3011         iv_ptr += cipher_iv_len;
3012         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3013
3014         /* Only copy over the offset data needed from src to dst in OOP,
3015          * if the auth and cipher offsets are not aligned
3016          */
3017         if (op_mode == OUT_OF_PLACE) {
3018                 if (cipher_offset > auth_offset)
3019                         rte_memcpy(
3020                                 rte_pktmbuf_mtod_offset(
3021                                         sym_op->m_dst,
3022                                         uint8_t *, auth_offset >> 3),
3023                                 rte_pktmbuf_mtod_offset(
3024                                         sym_op->m_src,
3025                                         uint8_t *, auth_offset >> 3),
3026                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3027         }
3028
3029         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3030                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3031                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3032                 sym_op->cipher.data.length = cipher_len;
3033                 sym_op->cipher.data.offset = cipher_offset;
3034         } else {
3035                 sym_op->cipher.data.length = cipher_len >> 3;
3036                 sym_op->cipher.data.offset = cipher_offset >> 3;
3037         }
3038
3039         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3040                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3041                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3042                 sym_op->auth.data.length = auth_len;
3043                 sym_op->auth.data.offset = auth_offset;
3044         } else {
3045                 sym_op->auth.data.length = auth_len >> 3;
3046                 sym_op->auth.data.offset = auth_offset >> 3;
3047         }
3048
3049         return 0;
3050 }
3051
3052 static int
3053 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3054 {
3055         struct crypto_testsuite_params *ts_params = &testsuite_params;
3056         struct crypto_unittest_params *ut_params = &unittest_params;
3057
3058         int retval;
3059         unsigned plaintext_pad_len;
3060         unsigned plaintext_len;
3061         uint8_t *plaintext;
3062         struct rte_cryptodev_info dev_info;
3063
3064         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3065         uint64_t feat_flags = dev_info.feature_flags;
3066
3067         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3068                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3069                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3070                 return TEST_SKIPPED;
3071         }
3072
3073         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3074                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3075                 printf("Device doesn't support RAW data-path APIs.\n");
3076                 return TEST_SKIPPED;
3077         }
3078
3079         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3080                 return TEST_SKIPPED;
3081
3082         /* Verify the capabilities */
3083         struct rte_cryptodev_sym_capability_idx cap_idx;
3084         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3085         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3086         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3087                         &cap_idx) == NULL)
3088                 return TEST_SKIPPED;
3089
3090         /* Create SNOW 3G session */
3091         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3092                         tdata->key.data, tdata->key.len,
3093                         tdata->auth_iv.len, tdata->digest.len,
3094                         RTE_CRYPTO_AUTH_OP_GENERATE,
3095                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3096         if (retval < 0)
3097                 return retval;
3098
3099         /* alloc mbuf and set payload */
3100         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3101
3102         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3103         rte_pktmbuf_tailroom(ut_params->ibuf));
3104
3105         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3106         /* Append data which is padded to a multiple of */
3107         /* the algorithms block size */
3108         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3109         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3110                                 plaintext_pad_len);
3111         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3112
3113         /* Create SNOW 3G operation */
3114         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3115                         tdata->auth_iv.data, tdata->auth_iv.len,
3116                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3117                         tdata->validAuthLenInBits.len,
3118                         0);
3119         if (retval < 0)
3120                 return retval;
3121
3122         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3123                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3124                                 ut_params->op, 0, 1, 1, 0);
3125         else
3126                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3127                                 ut_params->op);
3128         ut_params->obuf = ut_params->op->sym->m_src;
3129         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3130         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3131                         + plaintext_pad_len;
3132
3133         /* Validate obuf */
3134         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3135         ut_params->digest,
3136         tdata->digest.data,
3137         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3138         "SNOW 3G Generated auth tag not as expected");
3139
3140         return 0;
3141 }
3142
3143 static int
3144 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3145 {
3146         struct crypto_testsuite_params *ts_params = &testsuite_params;
3147         struct crypto_unittest_params *ut_params = &unittest_params;
3148
3149         int retval;
3150         unsigned plaintext_pad_len;
3151         unsigned plaintext_len;
3152         uint8_t *plaintext;
3153         struct rte_cryptodev_info dev_info;
3154
3155         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3156         uint64_t feat_flags = dev_info.feature_flags;
3157
3158         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3159                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3160                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3161                 return TEST_SKIPPED;
3162         }
3163
3164         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3165                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3166                 printf("Device doesn't support RAW data-path APIs.\n");
3167                 return TEST_SKIPPED;
3168         }
3169
3170         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3171                 return TEST_SKIPPED;
3172
3173         /* Verify the capabilities */
3174         struct rte_cryptodev_sym_capability_idx cap_idx;
3175         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3176         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3177         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3178                         &cap_idx) == NULL)
3179                 return TEST_SKIPPED;
3180
3181         /* Create SNOW 3G session */
3182         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3183                                 tdata->key.data, tdata->key.len,
3184                                 tdata->auth_iv.len, tdata->digest.len,
3185                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3186                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3187         if (retval < 0)
3188                 return retval;
3189         /* alloc mbuf and set payload */
3190         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3191
3192         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3193         rte_pktmbuf_tailroom(ut_params->ibuf));
3194
3195         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3196         /* Append data which is padded to a multiple of */
3197         /* the algorithms block size */
3198         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3199         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3200                                 plaintext_pad_len);
3201         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3202
3203         /* Create SNOW 3G operation */
3204         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3205                         tdata->digest.len,
3206                         tdata->auth_iv.data, tdata->auth_iv.len,
3207                         plaintext_pad_len,
3208                         RTE_CRYPTO_AUTH_OP_VERIFY,
3209                         tdata->validAuthLenInBits.len,
3210                         0);
3211         if (retval < 0)
3212                 return retval;
3213
3214         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3215                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3216                                 ut_params->op, 0, 1, 1, 0);
3217         else
3218                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3219                                 ut_params->op);
3220         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3221         ut_params->obuf = ut_params->op->sym->m_src;
3222         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3223                                 + plaintext_pad_len;
3224
3225         /* Validate obuf */
3226         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3227                 return 0;
3228         else
3229                 return -1;
3230
3231         return 0;
3232 }
3233
3234 static int
3235 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3236 {
3237         struct crypto_testsuite_params *ts_params = &testsuite_params;
3238         struct crypto_unittest_params *ut_params = &unittest_params;
3239
3240         int retval;
3241         unsigned plaintext_pad_len;
3242         unsigned plaintext_len;
3243         uint8_t *plaintext;
3244         struct rte_cryptodev_info dev_info;
3245
3246         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3247         uint64_t feat_flags = dev_info.feature_flags;
3248
3249         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3250                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3251                 printf("Device doesn't support RAW data-path APIs.\n");
3252                 return TEST_SKIPPED;
3253         }
3254
3255         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3256                 return TEST_SKIPPED;
3257
3258         /* Verify the capabilities */
3259         struct rte_cryptodev_sym_capability_idx cap_idx;
3260         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3261         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3262         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3263                         &cap_idx) == NULL)
3264                 return TEST_SKIPPED;
3265
3266         /* Create KASUMI session */
3267         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3268                         tdata->key.data, tdata->key.len,
3269                         0, tdata->digest.len,
3270                         RTE_CRYPTO_AUTH_OP_GENERATE,
3271                         RTE_CRYPTO_AUTH_KASUMI_F9);
3272         if (retval < 0)
3273                 return retval;
3274
3275         /* alloc mbuf and set payload */
3276         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3277
3278         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3279         rte_pktmbuf_tailroom(ut_params->ibuf));
3280
3281         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3282         /* Append data which is padded to a multiple of */
3283         /* the algorithms block size */
3284         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3285         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3286                                 plaintext_pad_len);
3287         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3288
3289         /* Create KASUMI operation */
3290         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3291                         NULL, 0,
3292                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3293                         tdata->plaintext.len,
3294                         0);
3295         if (retval < 0)
3296                 return retval;
3297
3298         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3299                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3300                         ut_params->op);
3301         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3302                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3303                                 ut_params->op, 0, 1, 1, 0);
3304         else
3305                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3306                         ut_params->op);
3307
3308         ut_params->obuf = ut_params->op->sym->m_src;
3309         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3310         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3311                         + plaintext_pad_len;
3312
3313         /* Validate obuf */
3314         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3315         ut_params->digest,
3316         tdata->digest.data,
3317         DIGEST_BYTE_LENGTH_KASUMI_F9,
3318         "KASUMI Generated auth tag not as expected");
3319
3320         return 0;
3321 }
3322
3323 static int
3324 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3325 {
3326         struct crypto_testsuite_params *ts_params = &testsuite_params;
3327         struct crypto_unittest_params *ut_params = &unittest_params;
3328
3329         int retval;
3330         unsigned plaintext_pad_len;
3331         unsigned plaintext_len;
3332         uint8_t *plaintext;
3333         struct rte_cryptodev_info dev_info;
3334
3335         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3336         uint64_t feat_flags = dev_info.feature_flags;
3337
3338         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3339                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3340                 printf("Device doesn't support RAW data-path APIs.\n");
3341                 return TEST_SKIPPED;
3342         }
3343
3344         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3345                 return TEST_SKIPPED;
3346
3347         /* Verify the capabilities */
3348         struct rte_cryptodev_sym_capability_idx cap_idx;
3349         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3350         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3351         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3352                         &cap_idx) == NULL)
3353                 return TEST_SKIPPED;
3354
3355         /* Create KASUMI session */
3356         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3357                                 tdata->key.data, tdata->key.len,
3358                                 0, tdata->digest.len,
3359                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3360                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3361         if (retval < 0)
3362                 return retval;
3363         /* alloc mbuf and set payload */
3364         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3365
3366         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3367         rte_pktmbuf_tailroom(ut_params->ibuf));
3368
3369         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3370         /* Append data which is padded to a multiple */
3371         /* of the algorithms block size */
3372         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3373         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3374                                 plaintext_pad_len);
3375         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3376
3377         /* Create KASUMI operation */
3378         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3379                         tdata->digest.len,
3380                         NULL, 0,
3381                         plaintext_pad_len,
3382                         RTE_CRYPTO_AUTH_OP_VERIFY,
3383                         tdata->plaintext.len,
3384                         0);
3385         if (retval < 0)
3386                 return retval;
3387
3388         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3389                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3390                                 ut_params->op, 0, 1, 1, 0);
3391         else
3392                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3393                                 ut_params->op);
3394         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3395         ut_params->obuf = ut_params->op->sym->m_src;
3396         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3397                                 + plaintext_pad_len;
3398
3399         /* Validate obuf */
3400         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3401                 return 0;
3402         else
3403                 return -1;
3404
3405         return 0;
3406 }
3407
3408 static int
3409 test_snow3g_hash_generate_test_case_1(void)
3410 {
3411         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3412 }
3413
3414 static int
3415 test_snow3g_hash_generate_test_case_2(void)
3416 {
3417         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3418 }
3419
3420 static int
3421 test_snow3g_hash_generate_test_case_3(void)
3422 {
3423         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3424 }
3425
3426 static int
3427 test_snow3g_hash_generate_test_case_4(void)
3428 {
3429         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3430 }
3431
3432 static int
3433 test_snow3g_hash_generate_test_case_5(void)
3434 {
3435         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3436 }
3437
3438 static int
3439 test_snow3g_hash_generate_test_case_6(void)
3440 {
3441         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3442 }
3443
3444 static int
3445 test_snow3g_hash_verify_test_case_1(void)
3446 {
3447         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3448
3449 }
3450
3451 static int
3452 test_snow3g_hash_verify_test_case_2(void)
3453 {
3454         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3455 }
3456
3457 static int
3458 test_snow3g_hash_verify_test_case_3(void)
3459 {
3460         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3461 }
3462
3463 static int
3464 test_snow3g_hash_verify_test_case_4(void)
3465 {
3466         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3467 }
3468
3469 static int
3470 test_snow3g_hash_verify_test_case_5(void)
3471 {
3472         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3473 }
3474
3475 static int
3476 test_snow3g_hash_verify_test_case_6(void)
3477 {
3478         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3479 }
3480
3481 static int
3482 test_kasumi_hash_generate_test_case_1(void)
3483 {
3484         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3485 }
3486
3487 static int
3488 test_kasumi_hash_generate_test_case_2(void)
3489 {
3490         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3491 }
3492
3493 static int
3494 test_kasumi_hash_generate_test_case_3(void)
3495 {
3496         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3497 }
3498
3499 static int
3500 test_kasumi_hash_generate_test_case_4(void)
3501 {
3502         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3503 }
3504
3505 static int
3506 test_kasumi_hash_generate_test_case_5(void)
3507 {
3508         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3509 }
3510
3511 static int
3512 test_kasumi_hash_generate_test_case_6(void)
3513 {
3514         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3515 }
3516
3517 static int
3518 test_kasumi_hash_verify_test_case_1(void)
3519 {
3520         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3521 }
3522
3523 static int
3524 test_kasumi_hash_verify_test_case_2(void)
3525 {
3526         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3527 }
3528
3529 static int
3530 test_kasumi_hash_verify_test_case_3(void)
3531 {
3532         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3533 }
3534
3535 static int
3536 test_kasumi_hash_verify_test_case_4(void)
3537 {
3538         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3539 }
3540
3541 static int
3542 test_kasumi_hash_verify_test_case_5(void)
3543 {
3544         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3545 }
3546
3547 static int
3548 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3549 {
3550         struct crypto_testsuite_params *ts_params = &testsuite_params;
3551         struct crypto_unittest_params *ut_params = &unittest_params;
3552
3553         int retval;
3554         uint8_t *plaintext, *ciphertext;
3555         unsigned plaintext_pad_len;
3556         unsigned plaintext_len;
3557         struct rte_cryptodev_info dev_info;
3558
3559         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3560         uint64_t feat_flags = dev_info.feature_flags;
3561
3562         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3563                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3564                 printf("Device doesn't support RAW data-path APIs.\n");
3565                 return TEST_SKIPPED;
3566         }
3567
3568         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3569                 return TEST_SKIPPED;
3570
3571         /* Verify the capabilities */
3572         struct rte_cryptodev_sym_capability_idx cap_idx;
3573         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3574         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3575         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3576                         &cap_idx) == NULL)
3577                 return TEST_SKIPPED;
3578
3579         /* Create KASUMI session */
3580         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3581                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3582                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3583                                         tdata->key.data, tdata->key.len,
3584                                         tdata->cipher_iv.len);
3585         if (retval < 0)
3586                 return retval;
3587
3588         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3589
3590         /* Clear mbuf payload */
3591         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3592                rte_pktmbuf_tailroom(ut_params->ibuf));
3593
3594         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3595         /* Append data which is padded to a multiple */
3596         /* of the algorithms block size */
3597         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3598         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3599                                 plaintext_pad_len);
3600         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3601
3602         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3603
3604         /* Create KASUMI operation */
3605         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3606                                 tdata->cipher_iv.len,
3607                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3608                                 tdata->validCipherOffsetInBits.len);
3609         if (retval < 0)
3610                 return retval;
3611
3612         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3613                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3614                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3615         else
3616                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3617                                 ut_params->op);
3618         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3619
3620         ut_params->obuf = ut_params->op->sym->m_dst;
3621         if (ut_params->obuf)
3622                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3623         else
3624                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3625
3626         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3627
3628         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3629                                 (tdata->validCipherOffsetInBits.len >> 3);
3630         /* Validate obuf */
3631         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3632                 ciphertext,
3633                 reference_ciphertext,
3634                 tdata->validCipherLenInBits.len,
3635                 "KASUMI Ciphertext data not as expected");
3636         return 0;
3637 }
3638
3639 static int
3640 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3641 {
3642         struct crypto_testsuite_params *ts_params = &testsuite_params;
3643         struct crypto_unittest_params *ut_params = &unittest_params;
3644
3645         int retval;
3646
3647         unsigned int plaintext_pad_len;
3648         unsigned int plaintext_len;
3649
3650         uint8_t buffer[10000];
3651         const uint8_t *ciphertext;
3652
3653         struct rte_cryptodev_info dev_info;
3654
3655         /* Verify the capabilities */
3656         struct rte_cryptodev_sym_capability_idx cap_idx;
3657         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3658         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3659         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3660                         &cap_idx) == NULL)
3661                 return TEST_SKIPPED;
3662
3663         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3664
3665         uint64_t feat_flags = dev_info.feature_flags;
3666
3667         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3668                 printf("Device doesn't support in-place scatter-gather. "
3669                                 "Test Skipped.\n");
3670                 return TEST_SKIPPED;
3671         }
3672
3673         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3674                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3675                 printf("Device doesn't support RAW data-path APIs.\n");
3676                 return TEST_SKIPPED;
3677         }
3678
3679         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3680                 return TEST_SKIPPED;
3681
3682         /* Create KASUMI session */
3683         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3684                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3685                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3686                                         tdata->key.data, tdata->key.len,
3687                                         tdata->cipher_iv.len);
3688         if (retval < 0)
3689                 return retval;
3690
3691         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3692
3693
3694         /* Append data which is padded to a multiple */
3695         /* of the algorithms block size */
3696         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3697
3698         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3699                         plaintext_pad_len, 10, 0);
3700
3701         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3702
3703         /* Create KASUMI operation */
3704         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3705                                 tdata->cipher_iv.len,
3706                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3707                                 tdata->validCipherOffsetInBits.len);
3708         if (retval < 0)
3709                 return retval;
3710
3711         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3712                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3713                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3714         else
3715                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3716                                                 ut_params->op);
3717         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3718
3719         ut_params->obuf = ut_params->op->sym->m_dst;
3720
3721         if (ut_params->obuf)
3722                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3723                                 plaintext_len, buffer);
3724         else
3725                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3726                                 tdata->validCipherOffsetInBits.len >> 3,
3727                                 plaintext_len, buffer);
3728
3729         /* Validate obuf */
3730         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3731
3732         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3733                                 (tdata->validCipherOffsetInBits.len >> 3);
3734         /* Validate obuf */
3735         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3736                 ciphertext,
3737                 reference_ciphertext,
3738                 tdata->validCipherLenInBits.len,
3739                 "KASUMI Ciphertext data not as expected");
3740         return 0;
3741 }
3742
3743 static int
3744 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3745 {
3746         struct crypto_testsuite_params *ts_params = &testsuite_params;
3747         struct crypto_unittest_params *ut_params = &unittest_params;
3748
3749         int retval;
3750         uint8_t *plaintext, *ciphertext;
3751         unsigned plaintext_pad_len;
3752         unsigned plaintext_len;
3753
3754         /* Verify the capabilities */
3755         struct rte_cryptodev_sym_capability_idx cap_idx;
3756         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3757         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3758         /* Data-path service does not support OOP */
3759         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3760                         &cap_idx) == NULL)
3761                 return TEST_SKIPPED;
3762
3763         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3764                 return TEST_SKIPPED;
3765
3766         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3767                 return TEST_SKIPPED;
3768
3769         /* Create KASUMI session */
3770         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3771                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3772                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3773                                         tdata->key.data, tdata->key.len,
3774                                         tdata->cipher_iv.len);
3775         if (retval < 0)
3776                 return retval;
3777
3778         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3779         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3780
3781         /* Clear mbuf payload */
3782         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3783                rte_pktmbuf_tailroom(ut_params->ibuf));
3784
3785         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3786         /* Append data which is padded to a multiple */
3787         /* of the algorithms block size */
3788         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3789         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3790                                 plaintext_pad_len);
3791         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3792         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3793
3794         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3795
3796         /* Create KASUMI operation */
3797         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3798                                 tdata->cipher_iv.len,
3799                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3800                                 tdata->validCipherOffsetInBits.len);
3801         if (retval < 0)
3802                 return retval;
3803
3804         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3805                                                 ut_params->op);
3806         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3807
3808         ut_params->obuf = ut_params->op->sym->m_dst;
3809         if (ut_params->obuf)
3810                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3811         else
3812                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3813
3814         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3815
3816         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3817                                 (tdata->validCipherOffsetInBits.len >> 3);
3818         /* Validate obuf */
3819         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3820                 ciphertext,
3821                 reference_ciphertext,
3822                 tdata->validCipherLenInBits.len,
3823                 "KASUMI Ciphertext data not as expected");
3824         return 0;
3825 }
3826
3827 static int
3828 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3829 {
3830         struct crypto_testsuite_params *ts_params = &testsuite_params;
3831         struct crypto_unittest_params *ut_params = &unittest_params;
3832
3833         int retval;
3834         unsigned int plaintext_pad_len;
3835         unsigned int plaintext_len;
3836
3837         const uint8_t *ciphertext;
3838         uint8_t buffer[2048];
3839
3840         struct rte_cryptodev_info dev_info;
3841
3842         /* Verify the capabilities */
3843         struct rte_cryptodev_sym_capability_idx cap_idx;
3844         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3845         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3846         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3847                         &cap_idx) == NULL)
3848                 return TEST_SKIPPED;
3849
3850         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3851                 return TEST_SKIPPED;
3852
3853         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3854                 return TEST_SKIPPED;
3855
3856         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3857
3858         uint64_t feat_flags = dev_info.feature_flags;
3859         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3860                 printf("Device doesn't support out-of-place scatter-gather "
3861                                 "in both input and output mbufs. "
3862                                 "Test Skipped.\n");
3863                 return TEST_SKIPPED;
3864         }
3865
3866         /* Create KASUMI session */
3867         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3868                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3869                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3870                                         tdata->key.data, tdata->key.len,
3871                                         tdata->cipher_iv.len);
3872         if (retval < 0)
3873                 return retval;
3874
3875         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3876         /* Append data which is padded to a multiple */
3877         /* of the algorithms block size */
3878         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3879
3880         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3881                         plaintext_pad_len, 10, 0);
3882         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3883                         plaintext_pad_len, 3, 0);
3884
3885         /* Append data which is padded to a multiple */
3886         /* of the algorithms block size */
3887         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3888
3889         /* Create KASUMI operation */
3890         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3891                                 tdata->cipher_iv.len,
3892                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3893                                 tdata->validCipherOffsetInBits.len);
3894         if (retval < 0)
3895                 return retval;
3896
3897         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3898                                                 ut_params->op);
3899         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3900
3901         ut_params->obuf = ut_params->op->sym->m_dst;
3902         if (ut_params->obuf)
3903                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3904                                 plaintext_pad_len, buffer);
3905         else
3906                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3907                                 tdata->validCipherOffsetInBits.len >> 3,
3908                                 plaintext_pad_len, buffer);
3909
3910         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3911                                 (tdata->validCipherOffsetInBits.len >> 3);
3912         /* Validate obuf */
3913         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3914                 ciphertext,
3915                 reference_ciphertext,
3916                 tdata->validCipherLenInBits.len,
3917                 "KASUMI Ciphertext data not as expected");
3918         return 0;
3919 }
3920
3921
3922 static int
3923 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3924 {
3925         struct crypto_testsuite_params *ts_params = &testsuite_params;
3926         struct crypto_unittest_params *ut_params = &unittest_params;
3927
3928         int retval;
3929         uint8_t *ciphertext, *plaintext;
3930         unsigned ciphertext_pad_len;
3931         unsigned ciphertext_len;
3932
3933         /* Verify the capabilities */
3934         struct rte_cryptodev_sym_capability_idx cap_idx;
3935         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3936         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3937         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3938                         &cap_idx) == NULL)
3939                 return TEST_SKIPPED;
3940
3941         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3942                 return TEST_SKIPPED;
3943
3944         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3945                 return TEST_SKIPPED;
3946
3947         /* Create KASUMI session */
3948         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3949                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3950                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3951                                         tdata->key.data, tdata->key.len,
3952                                         tdata->cipher_iv.len);
3953         if (retval < 0)
3954                 return retval;
3955
3956         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3957         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3958
3959         /* Clear mbuf payload */
3960         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3961                rte_pktmbuf_tailroom(ut_params->ibuf));
3962
3963         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3964         /* Append data which is padded to a multiple */
3965         /* of the algorithms block size */
3966         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3967         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3968                                 ciphertext_pad_len);
3969         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3970         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3971
3972         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3973
3974         /* Create KASUMI operation */
3975         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3976                                 tdata->cipher_iv.len,
3977                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3978                                 tdata->validCipherOffsetInBits.len);
3979         if (retval < 0)
3980                 return retval;
3981
3982         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3983                                                 ut_params->op);
3984         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3985
3986         ut_params->obuf = ut_params->op->sym->m_dst;
3987         if (ut_params->obuf)
3988                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3989         else
3990                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3991
3992         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3993
3994         const uint8_t *reference_plaintext = tdata->plaintext.data +
3995                                 (tdata->validCipherOffsetInBits.len >> 3);
3996         /* Validate obuf */
3997         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3998                 plaintext,
3999                 reference_plaintext,
4000                 tdata->validCipherLenInBits.len,
4001                 "KASUMI Plaintext data not as expected");
4002         return 0;
4003 }
4004
4005 static int
4006 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4007 {
4008         struct crypto_testsuite_params *ts_params = &testsuite_params;
4009         struct crypto_unittest_params *ut_params = &unittest_params;
4010
4011         int retval;
4012         uint8_t *ciphertext, *plaintext;
4013         unsigned ciphertext_pad_len;
4014         unsigned ciphertext_len;
4015         struct rte_cryptodev_info dev_info;
4016
4017         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4018         uint64_t feat_flags = dev_info.feature_flags;
4019
4020         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4021                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4022                 printf("Device doesn't support RAW data-path APIs.\n");
4023                 return TEST_SKIPPED;
4024         }
4025
4026         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4027                 return TEST_SKIPPED;
4028
4029         /* Verify the capabilities */
4030         struct rte_cryptodev_sym_capability_idx cap_idx;
4031         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4032         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4033         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4034                         &cap_idx) == NULL)
4035                 return TEST_SKIPPED;
4036
4037         /* Create KASUMI session */
4038         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4039                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4040                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4041                                         tdata->key.data, tdata->key.len,
4042                                         tdata->cipher_iv.len);
4043         if (retval < 0)
4044                 return retval;
4045
4046         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4047
4048         /* Clear mbuf payload */
4049         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4050                rte_pktmbuf_tailroom(ut_params->ibuf));
4051
4052         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4053         /* Append data which is padded to a multiple */
4054         /* of the algorithms block size */
4055         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4056         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4057                                 ciphertext_pad_len);
4058         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4059
4060         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4061
4062         /* Create KASUMI operation */
4063         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4064                                         tdata->cipher_iv.len,
4065                                         tdata->ciphertext.len,
4066                                         tdata->validCipherOffsetInBits.len);
4067         if (retval < 0)
4068                 return retval;
4069
4070         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4071                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4072                                 ut_params->op, 1, 0, 1, 0);
4073         else
4074                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4075                                                 ut_params->op);
4076         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4077
4078         ut_params->obuf = ut_params->op->sym->m_dst;
4079         if (ut_params->obuf)
4080                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4081         else
4082                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4083
4084         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4085
4086         const uint8_t *reference_plaintext = tdata->plaintext.data +
4087                                 (tdata->validCipherOffsetInBits.len >> 3);
4088         /* Validate obuf */
4089         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4090                 plaintext,
4091                 reference_plaintext,
4092                 tdata->validCipherLenInBits.len,
4093                 "KASUMI Plaintext data not as expected");
4094         return 0;
4095 }
4096
4097 static int
4098 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4099 {
4100         struct crypto_testsuite_params *ts_params = &testsuite_params;
4101         struct crypto_unittest_params *ut_params = &unittest_params;
4102
4103         int retval;
4104         uint8_t *plaintext, *ciphertext;
4105         unsigned plaintext_pad_len;
4106         unsigned plaintext_len;
4107         struct rte_cryptodev_info dev_info;
4108
4109         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4110         uint64_t feat_flags = dev_info.feature_flags;
4111
4112         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4113                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4114                 printf("Device doesn't support RAW data-path APIs.\n");
4115                 return TEST_SKIPPED;
4116         }
4117
4118         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4119                 return TEST_SKIPPED;
4120
4121         /* Verify the capabilities */
4122         struct rte_cryptodev_sym_capability_idx cap_idx;
4123         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4124         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4125         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4126                         &cap_idx) == NULL)
4127                 return TEST_SKIPPED;
4128
4129         /* Create SNOW 3G session */
4130         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4131                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4132                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4133                                         tdata->key.data, tdata->key.len,
4134                                         tdata->cipher_iv.len);
4135         if (retval < 0)
4136                 return retval;
4137
4138         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4139
4140         /* Clear mbuf payload */
4141         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4142                rte_pktmbuf_tailroom(ut_params->ibuf));
4143
4144         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4145         /* Append data which is padded to a multiple of */
4146         /* the algorithms block size */
4147         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4148         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4149                                 plaintext_pad_len);
4150         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4151
4152         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4153
4154         /* Create SNOW 3G operation */
4155         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4156                                         tdata->cipher_iv.len,
4157                                         tdata->validCipherLenInBits.len,
4158                                         0);
4159         if (retval < 0)
4160                 return retval;
4161
4162         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4163                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4164                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4165         else
4166                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4167                                                 ut_params->op);
4168         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4169
4170         ut_params->obuf = ut_params->op->sym->m_dst;
4171         if (ut_params->obuf)
4172                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4173         else
4174                 ciphertext = plaintext;
4175
4176         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4177
4178         /* Validate obuf */
4179         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4180                 ciphertext,
4181                 tdata->ciphertext.data,
4182                 tdata->validDataLenInBits.len,
4183                 "SNOW 3G Ciphertext data not as expected");
4184         return 0;
4185 }
4186
4187
4188 static int
4189 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4190 {
4191         struct crypto_testsuite_params *ts_params = &testsuite_params;
4192         struct crypto_unittest_params *ut_params = &unittest_params;
4193         uint8_t *plaintext, *ciphertext;
4194
4195         int retval;
4196         unsigned plaintext_pad_len;
4197         unsigned plaintext_len;
4198
4199         /* Verify the capabilities */
4200         struct rte_cryptodev_sym_capability_idx cap_idx;
4201         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4202         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4203         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4204                         &cap_idx) == NULL)
4205                 return TEST_SKIPPED;
4206
4207         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4208                 return TEST_SKIPPED;
4209
4210         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4211                 return TEST_SKIPPED;
4212
4213         /* Create SNOW 3G session */
4214         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4215                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4216                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4217                                         tdata->key.data, tdata->key.len,
4218                                         tdata->cipher_iv.len);
4219         if (retval < 0)
4220                 return retval;
4221
4222         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4223         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4224
4225         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4226                         "Failed to allocate input buffer in mempool");
4227         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4228                         "Failed to allocate output buffer in mempool");
4229
4230         /* Clear mbuf payload */
4231         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4232                rte_pktmbuf_tailroom(ut_params->ibuf));
4233
4234         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4235         /* Append data which is padded to a multiple of */
4236         /* the algorithms block size */
4237         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4238         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4239                                 plaintext_pad_len);
4240         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4241         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4242
4243         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4244
4245         /* Create SNOW 3G operation */
4246         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4247                                         tdata->cipher_iv.len,
4248                                         tdata->validCipherLenInBits.len,
4249                                         0);
4250         if (retval < 0)
4251                 return retval;
4252
4253         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4254                                                 ut_params->op);
4255         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4256
4257         ut_params->obuf = ut_params->op->sym->m_dst;
4258         if (ut_params->obuf)
4259                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4260         else
4261                 ciphertext = plaintext;
4262
4263         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4264
4265         /* Validate obuf */
4266         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4267                 ciphertext,
4268                 tdata->ciphertext.data,
4269                 tdata->validDataLenInBits.len,
4270                 "SNOW 3G Ciphertext data not as expected");
4271         return 0;
4272 }
4273
4274 static int
4275 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4276 {
4277         struct crypto_testsuite_params *ts_params = &testsuite_params;
4278         struct crypto_unittest_params *ut_params = &unittest_params;
4279
4280         int retval;
4281         unsigned int plaintext_pad_len;
4282         unsigned int plaintext_len;
4283         uint8_t buffer[10000];
4284         const uint8_t *ciphertext;
4285
4286         struct rte_cryptodev_info dev_info;
4287
4288         /* Verify the capabilities */
4289         struct rte_cryptodev_sym_capability_idx cap_idx;
4290         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4291         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4292         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4293                         &cap_idx) == NULL)
4294                 return TEST_SKIPPED;
4295
4296         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4297                 return TEST_SKIPPED;
4298
4299         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4300                 return TEST_SKIPPED;
4301
4302         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4303
4304         uint64_t feat_flags = dev_info.feature_flags;
4305
4306         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4307                 printf("Device doesn't support out-of-place scatter-gather "
4308                                 "in both input and output mbufs. "
4309                                 "Test Skipped.\n");
4310                 return TEST_SKIPPED;
4311         }
4312
4313         /* Create SNOW 3G session */
4314         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4315                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4316                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4317                                         tdata->key.data, tdata->key.len,
4318                                         tdata->cipher_iv.len);
4319         if (retval < 0)
4320                 return retval;
4321
4322         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4323         /* Append data which is padded to a multiple of */
4324         /* the algorithms block size */
4325         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4326
4327         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4328                         plaintext_pad_len, 10, 0);
4329         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4330                         plaintext_pad_len, 3, 0);
4331
4332         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4333                         "Failed to allocate input buffer in mempool");
4334         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4335                         "Failed to allocate output buffer in mempool");
4336
4337         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4338
4339         /* Create SNOW 3G operation */
4340         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4341                                         tdata->cipher_iv.len,
4342                                         tdata->validCipherLenInBits.len,
4343                                         0);
4344         if (retval < 0)
4345                 return retval;
4346
4347         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4348                                                 ut_params->op);
4349         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4350
4351         ut_params->obuf = ut_params->op->sym->m_dst;
4352         if (ut_params->obuf)
4353                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4354                                 plaintext_len, buffer);
4355         else
4356                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4357                                 plaintext_len, buffer);
4358
4359         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4360
4361         /* Validate obuf */
4362         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4363                 ciphertext,
4364                 tdata->ciphertext.data,
4365                 tdata->validDataLenInBits.len,
4366                 "SNOW 3G Ciphertext data not as expected");
4367
4368         return 0;
4369 }
4370
4371 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4372 static void
4373 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4374 {
4375         uint8_t curr_byte, prev_byte;
4376         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4377         uint8_t lower_byte_mask = (1 << offset) - 1;
4378         unsigned i;
4379
4380         prev_byte = buffer[0];
4381         buffer[0] >>= offset;
4382
4383         for (i = 1; i < length_in_bytes; i++) {
4384                 curr_byte = buffer[i];
4385                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4386                                 (curr_byte >> offset);
4387                 prev_byte = curr_byte;
4388         }
4389 }
4390
4391 static int
4392 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4393 {
4394         struct crypto_testsuite_params *ts_params = &testsuite_params;
4395         struct crypto_unittest_params *ut_params = &unittest_params;
4396         uint8_t *plaintext, *ciphertext;
4397         int retval;
4398         uint32_t plaintext_len;
4399         uint32_t plaintext_pad_len;
4400         uint8_t extra_offset = 4;
4401         uint8_t *expected_ciphertext_shifted;
4402         struct rte_cryptodev_info dev_info;
4403
4404         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4405         uint64_t feat_flags = dev_info.feature_flags;
4406
4407         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4408                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4409                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4410                 return TEST_SKIPPED;
4411         }
4412
4413         /* Verify the capabilities */
4414         struct rte_cryptodev_sym_capability_idx cap_idx;
4415         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4416         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4417         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4418                         &cap_idx) == NULL)
4419                 return TEST_SKIPPED;
4420
4421         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4422                 return TEST_SKIPPED;
4423
4424         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4425                 return TEST_SKIPPED;
4426
4427         /* Create SNOW 3G session */
4428         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4429                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4430                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4431                                         tdata->key.data, tdata->key.len,
4432                                         tdata->cipher_iv.len);
4433         if (retval < 0)
4434                 return retval;
4435
4436         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4437         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4438
4439         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4440                         "Failed to allocate input buffer in mempool");
4441         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4442                         "Failed to allocate output buffer in mempool");
4443
4444         /* Clear mbuf payload */
4445         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4446                rte_pktmbuf_tailroom(ut_params->ibuf));
4447
4448         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4449         /*
4450          * Append data which is padded to a
4451          * multiple of the algorithms block size
4452          */
4453         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4454
4455         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4456                                                 plaintext_pad_len);
4457
4458         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4459
4460         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4461         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4462
4463 #ifdef RTE_APP_TEST_DEBUG
4464         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4465 #endif
4466         /* Create SNOW 3G operation */
4467         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4468                                         tdata->cipher_iv.len,
4469                                         tdata->validCipherLenInBits.len,
4470                                         extra_offset);
4471         if (retval < 0)
4472                 return retval;
4473
4474         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4475                                                 ut_params->op);
4476         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4477
4478         ut_params->obuf = ut_params->op->sym->m_dst;
4479         if (ut_params->obuf)
4480                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4481         else
4482                 ciphertext = plaintext;
4483
4484 #ifdef RTE_APP_TEST_DEBUG
4485         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4486 #endif
4487
4488         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4489
4490         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4491                         "failed to reserve memory for ciphertext shifted\n");
4492
4493         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4494                         ceil_byte_length(tdata->ciphertext.len));
4495         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4496                         extra_offset);
4497         /* Validate obuf */
4498         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4499                 ciphertext,
4500                 expected_ciphertext_shifted,
4501                 tdata->validDataLenInBits.len,
4502                 extra_offset,
4503                 "SNOW 3G Ciphertext data not as expected");
4504         return 0;
4505 }
4506
4507 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4508 {
4509         struct crypto_testsuite_params *ts_params = &testsuite_params;
4510         struct crypto_unittest_params *ut_params = &unittest_params;
4511
4512         int retval;
4513
4514         uint8_t *plaintext, *ciphertext;
4515         unsigned ciphertext_pad_len;
4516         unsigned ciphertext_len;
4517         struct rte_cryptodev_info dev_info;
4518
4519         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4520         uint64_t feat_flags = dev_info.feature_flags;
4521
4522         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4523                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4524                 printf("Device doesn't support RAW data-path APIs.\n");
4525                 return TEST_SKIPPED;
4526         }
4527
4528         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4529                 return TEST_SKIPPED;
4530
4531         /* Verify the capabilities */
4532         struct rte_cryptodev_sym_capability_idx cap_idx;
4533         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4534         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4535         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4536                         &cap_idx) == NULL)
4537                 return TEST_SKIPPED;
4538
4539         /* Create SNOW 3G session */
4540         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4541                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4542                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4543                                         tdata->key.data, tdata->key.len,
4544                                         tdata->cipher_iv.len);
4545         if (retval < 0)
4546                 return retval;
4547
4548         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4549
4550         /* Clear mbuf payload */
4551         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4552                rte_pktmbuf_tailroom(ut_params->ibuf));
4553
4554         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4555         /* Append data which is padded to a multiple of */
4556         /* the algorithms block size */
4557         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4558         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4559                                 ciphertext_pad_len);
4560         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4561
4562         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4563
4564         /* Create SNOW 3G operation */
4565         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4566                                         tdata->cipher_iv.len,
4567                                         tdata->validCipherLenInBits.len,
4568                                         tdata->cipher.offset_bits);
4569         if (retval < 0)
4570                 return retval;
4571
4572         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4573                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4574                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4575         else
4576                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4577                                                 ut_params->op);
4578         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4579         ut_params->obuf = ut_params->op->sym->m_dst;
4580         if (ut_params->obuf)
4581                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4582         else
4583                 plaintext = ciphertext;
4584
4585         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4586
4587         /* Validate obuf */
4588         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4589                                 tdata->plaintext.data,
4590                                 tdata->validDataLenInBits.len,
4591                                 "SNOW 3G Plaintext data not as expected");
4592         return 0;
4593 }
4594
4595 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4596 {
4597         struct crypto_testsuite_params *ts_params = &testsuite_params;
4598         struct crypto_unittest_params *ut_params = &unittest_params;
4599
4600         int retval;
4601
4602         uint8_t *plaintext, *ciphertext;
4603         unsigned ciphertext_pad_len;
4604         unsigned ciphertext_len;
4605
4606         /* Verify the capabilities */
4607         struct rte_cryptodev_sym_capability_idx cap_idx;
4608         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4609         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4610         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4611                         &cap_idx) == NULL)
4612                 return TEST_SKIPPED;
4613
4614         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4615                 return TEST_SKIPPED;
4616
4617         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4618                 return TEST_SKIPPED;
4619
4620         /* Create SNOW 3G session */
4621         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4622                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4623                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4624                                         tdata->key.data, tdata->key.len,
4625                                         tdata->cipher_iv.len);
4626         if (retval < 0)
4627                 return retval;
4628
4629         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4630         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4631
4632         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4633                         "Failed to allocate input buffer");
4634         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4635                         "Failed to allocate output buffer");
4636
4637         /* Clear mbuf payload */
4638         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4639                rte_pktmbuf_tailroom(ut_params->ibuf));
4640
4641         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4642                        rte_pktmbuf_tailroom(ut_params->obuf));
4643
4644         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4645         /* Append data which is padded to a multiple of */
4646         /* the algorithms block size */
4647         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4648         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4649                                 ciphertext_pad_len);
4650         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4651         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4652
4653         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4654
4655         /* Create SNOW 3G operation */
4656         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4657                                         tdata->cipher_iv.len,
4658                                         tdata->validCipherLenInBits.len,
4659                                         0);
4660         if (retval < 0)
4661                 return retval;
4662
4663         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4664                                                 ut_params->op);
4665         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4666         ut_params->obuf = ut_params->op->sym->m_dst;
4667         if (ut_params->obuf)
4668                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4669         else
4670                 plaintext = ciphertext;
4671
4672         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4673
4674         /* Validate obuf */
4675         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4676                                 tdata->plaintext.data,
4677                                 tdata->validDataLenInBits.len,
4678                                 "SNOW 3G Plaintext data not as expected");
4679         return 0;
4680 }
4681
4682 static int
4683 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4684 {
4685         struct crypto_testsuite_params *ts_params = &testsuite_params;
4686         struct crypto_unittest_params *ut_params = &unittest_params;
4687
4688         int retval;
4689
4690         uint8_t *plaintext, *ciphertext;
4691         unsigned int plaintext_pad_len;
4692         unsigned int plaintext_len;
4693
4694         struct rte_cryptodev_info dev_info;
4695         struct rte_cryptodev_sym_capability_idx cap_idx;
4696
4697         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4698         uint64_t feat_flags = dev_info.feature_flags;
4699
4700         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4701                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4702                         (tdata->validDataLenInBits.len % 8 != 0))) {
4703                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4704                 return TEST_SKIPPED;
4705         }
4706
4707         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4708                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4709                 printf("Device doesn't support RAW data-path APIs.\n");
4710                 return TEST_SKIPPED;
4711         }
4712
4713         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4714                 return TEST_SKIPPED;
4715
4716         /* Check if device supports ZUC EEA3 */
4717         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4718         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4719
4720         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4721                         &cap_idx) == NULL)
4722                 return TEST_SKIPPED;
4723
4724         /* Check if device supports ZUC EIA3 */
4725         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4726         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4727
4728         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4729                         &cap_idx) == NULL)
4730                 return TEST_SKIPPED;
4731
4732         /* Create ZUC session */
4733         retval = create_zuc_cipher_auth_encrypt_generate_session(
4734                         ts_params->valid_devs[0],
4735                         tdata);
4736         if (retval != 0)
4737                 return retval;
4738         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4739
4740         /* clear mbuf payload */
4741         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4742                         rte_pktmbuf_tailroom(ut_params->ibuf));
4743
4744         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4745         /* Append data which is padded to a multiple of */
4746         /* the algorithms block size */
4747         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4748         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4749                                 plaintext_pad_len);
4750         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4751
4752         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4753
4754         /* Create ZUC operation */
4755         retval = create_zuc_cipher_hash_generate_operation(tdata);
4756         if (retval < 0)
4757                 return retval;
4758
4759         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4760                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4761                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4762         else
4763                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4764                         ut_params->op);
4765         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4766         ut_params->obuf = ut_params->op->sym->m_src;
4767         if (ut_params->obuf)
4768                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4769         else
4770                 ciphertext = plaintext;
4771
4772         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4773         /* Validate obuf */
4774         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4775                         ciphertext,
4776                         tdata->ciphertext.data,
4777                         tdata->validDataLenInBits.len,
4778                         "ZUC Ciphertext data not as expected");
4779
4780         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4781             + plaintext_pad_len;
4782
4783         /* Validate obuf */
4784         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4785                         ut_params->digest,
4786                         tdata->digest.data,
4787                         4,
4788                         "ZUC Generated auth tag not as expected");
4789         return 0;
4790 }
4791
4792 static int
4793 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4794 {
4795         struct crypto_testsuite_params *ts_params = &testsuite_params;
4796         struct crypto_unittest_params *ut_params = &unittest_params;
4797
4798         int retval;
4799
4800         uint8_t *plaintext, *ciphertext;
4801         unsigned plaintext_pad_len;
4802         unsigned plaintext_len;
4803         struct rte_cryptodev_info dev_info;
4804
4805         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4806         uint64_t feat_flags = dev_info.feature_flags;
4807
4808         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4809                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4810                 printf("Device doesn't support RAW data-path APIs.\n");
4811                 return TEST_SKIPPED;
4812         }
4813
4814         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4815                 return TEST_SKIPPED;
4816
4817         /* Verify the capabilities */
4818         struct rte_cryptodev_sym_capability_idx cap_idx;
4819         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4820         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4821         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4822                         &cap_idx) == NULL)
4823                 return TEST_SKIPPED;
4824         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4825         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4826         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4827                         &cap_idx) == NULL)
4828                 return TEST_SKIPPED;
4829
4830         /* Create SNOW 3G session */
4831         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4832                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4833                         RTE_CRYPTO_AUTH_OP_GENERATE,
4834                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4835                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4836                         tdata->key.data, tdata->key.len,
4837                         tdata->auth_iv.len, tdata->digest.len,
4838                         tdata->cipher_iv.len);
4839         if (retval != 0)
4840                 return retval;
4841         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4842
4843         /* clear mbuf payload */
4844         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4845                         rte_pktmbuf_tailroom(ut_params->ibuf));
4846
4847         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4848         /* Append data which is padded to a multiple of */
4849         /* the algorithms block size */
4850         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4851         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4852                                 plaintext_pad_len);
4853         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4854
4855         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4856
4857         /* Create SNOW 3G operation */
4858         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4859                         tdata->digest.len, tdata->auth_iv.data,
4860                         tdata->auth_iv.len,
4861                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4862                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4863                         tdata->validCipherLenInBits.len,
4864                         0,
4865                         tdata->validAuthLenInBits.len,
4866                         0
4867                         );
4868         if (retval < 0)
4869                 return retval;
4870
4871         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4872                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4873                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4874         else
4875                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4876                         ut_params->op);
4877         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4878         ut_params->obuf = ut_params->op->sym->m_src;
4879         if (ut_params->obuf)
4880                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4881         else
4882                 ciphertext = plaintext;
4883
4884         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4885         /* Validate obuf */
4886         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4887                         ciphertext,
4888                         tdata->ciphertext.data,
4889                         tdata->validDataLenInBits.len,
4890                         "SNOW 3G Ciphertext data not as expected");
4891
4892         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4893             + plaintext_pad_len;
4894
4895         /* Validate obuf */
4896         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4897                         ut_params->digest,
4898                         tdata->digest.data,
4899                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4900                         "SNOW 3G Generated auth tag not as expected");
4901         return 0;
4902 }
4903
4904 static int
4905 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4906         uint8_t op_mode, uint8_t verify)
4907 {
4908         struct crypto_testsuite_params *ts_params = &testsuite_params;
4909         struct crypto_unittest_params *ut_params = &unittest_params;
4910
4911         int retval;
4912
4913         uint8_t *plaintext = NULL, *ciphertext = NULL;
4914         unsigned int plaintext_pad_len;
4915         unsigned int plaintext_len;
4916         unsigned int ciphertext_pad_len;
4917         unsigned int ciphertext_len;
4918
4919         struct rte_cryptodev_info dev_info;
4920
4921         /* Verify the capabilities */
4922         struct rte_cryptodev_sym_capability_idx cap_idx;
4923         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4924         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4925         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4926                         &cap_idx) == NULL)
4927                 return TEST_SKIPPED;
4928         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4929         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4930         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4931                         &cap_idx) == NULL)
4932                 return TEST_SKIPPED;
4933
4934         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4935                 return TEST_SKIPPED;
4936
4937         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4938
4939         uint64_t feat_flags = dev_info.feature_flags;
4940
4941         if (op_mode == OUT_OF_PLACE) {
4942                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4943                         printf("Device doesn't support digest encrypted.\n");
4944                         return TEST_SKIPPED;
4945                 }
4946                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4947                         return TEST_SKIPPED;
4948         }
4949
4950         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4951                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4952                 printf("Device doesn't support RAW data-path APIs.\n");
4953                 return TEST_SKIPPED;
4954         }
4955
4956         /* Create SNOW 3G session */
4957         retval = create_wireless_algo_auth_cipher_session(
4958                         ts_params->valid_devs[0],
4959                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4960                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4961                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4962                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4963                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4964                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4965                         tdata->key.data, tdata->key.len,
4966                         tdata->auth_iv.len, tdata->digest.len,
4967                         tdata->cipher_iv.len);
4968         if (retval != 0)
4969                 return retval;
4970
4971         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4972         if (op_mode == OUT_OF_PLACE)
4973                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4974
4975         /* clear mbuf payload */
4976         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4977                 rte_pktmbuf_tailroom(ut_params->ibuf));
4978         if (op_mode == OUT_OF_PLACE)
4979                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4980                         rte_pktmbuf_tailroom(ut_params->obuf));
4981
4982         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4983         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4984         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4985         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4986
4987         if (verify) {
4988                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4989                                         ciphertext_pad_len);
4990                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4991                 if (op_mode == OUT_OF_PLACE)
4992                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4993                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4994                         ciphertext_len);
4995         } else {
4996                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4997                                         plaintext_pad_len);
4998                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4999                 if (op_mode == OUT_OF_PLACE)
5000                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5001                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5002         }
5003
5004         /* Create SNOW 3G operation */
5005         retval = create_wireless_algo_auth_cipher_operation(
5006                 tdata->digest.data, tdata->digest.len,
5007                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5008                 tdata->auth_iv.data, tdata->auth_iv.len,
5009                 (tdata->digest.offset_bytes == 0 ?
5010                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5011                         : tdata->digest.offset_bytes),
5012                 tdata->validCipherLenInBits.len,
5013                 tdata->cipher.offset_bits,
5014                 tdata->validAuthLenInBits.len,
5015                 tdata->auth.offset_bits,
5016                 op_mode, 0, verify);
5017
5018         if (retval < 0)
5019                 return retval;
5020
5021         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5022                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5023                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5024         else
5025                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5026                         ut_params->op);
5027
5028         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5029
5030         ut_params->obuf = (op_mode == IN_PLACE ?
5031                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5032
5033         if (verify) {
5034                 if (ut_params->obuf)
5035                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5036                                                         uint8_t *);
5037                 else
5038                         plaintext = ciphertext +
5039                                 (tdata->cipher.offset_bits >> 3);
5040
5041                 debug_hexdump(stdout, "plaintext:", plaintext,
5042                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5043                 debug_hexdump(stdout, "plaintext expected:",
5044                         tdata->plaintext.data,
5045                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5046         } else {
5047                 if (ut_params->obuf)
5048                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5049                                                         uint8_t *);
5050                 else
5051                         ciphertext = plaintext;
5052
5053                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5054                         ciphertext_len);
5055                 debug_hexdump(stdout, "ciphertext expected:",
5056                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5057
5058                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5059                         + (tdata->digest.offset_bytes == 0 ?
5060                 plaintext_pad_len : tdata->digest.offset_bytes);
5061
5062                 debug_hexdump(stdout, "digest:", ut_params->digest,
5063                         tdata->digest.len);
5064                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5065                                 tdata->digest.len);
5066         }
5067
5068         /* Validate obuf */
5069         if (verify) {
5070                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5071                         plaintext,
5072                         tdata->plaintext.data,
5073                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5074                          (tdata->digest.len << 3)),
5075                         tdata->cipher.offset_bits,
5076                         "SNOW 3G Plaintext data not as expected");
5077         } else {
5078                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5079                         ciphertext,
5080                         tdata->ciphertext.data,
5081                         (tdata->validDataLenInBits.len -
5082                          tdata->cipher.offset_bits),
5083                         tdata->cipher.offset_bits,
5084                         "SNOW 3G Ciphertext data not as expected");
5085
5086                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5087                         ut_params->digest,
5088                         tdata->digest.data,
5089                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5090                         "SNOW 3G Generated auth tag not as expected");
5091         }
5092         return 0;
5093 }
5094
5095 static int
5096 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5097         uint8_t op_mode, uint8_t verify)
5098 {
5099         struct crypto_testsuite_params *ts_params = &testsuite_params;
5100         struct crypto_unittest_params *ut_params = &unittest_params;
5101
5102         int retval;
5103
5104         const uint8_t *plaintext = NULL;
5105         const uint8_t *ciphertext = NULL;
5106         const uint8_t *digest = NULL;
5107         unsigned int plaintext_pad_len;
5108         unsigned int plaintext_len;
5109         unsigned int ciphertext_pad_len;
5110         unsigned int ciphertext_len;
5111         uint8_t buffer[10000];
5112         uint8_t digest_buffer[10000];
5113
5114         struct rte_cryptodev_info dev_info;
5115
5116         /* Verify the capabilities */
5117         struct rte_cryptodev_sym_capability_idx cap_idx;
5118         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5119         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5120         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5121                         &cap_idx) == NULL)
5122                 return TEST_SKIPPED;
5123         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5124         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5125         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5126                         &cap_idx) == NULL)
5127                 return TEST_SKIPPED;
5128
5129         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5130                 return TEST_SKIPPED;
5131
5132         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5133
5134         uint64_t feat_flags = dev_info.feature_flags;
5135
5136         if (op_mode == IN_PLACE) {
5137                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5138                         printf("Device doesn't support in-place scatter-gather "
5139                                         "in both input and output mbufs.\n");
5140                         return TEST_SKIPPED;
5141                 }
5142                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5143                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5144                         printf("Device doesn't support RAW data-path APIs.\n");
5145                         return TEST_SKIPPED;
5146                 }
5147         } else {
5148                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5149                         return TEST_SKIPPED;
5150                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5151                         printf("Device doesn't support out-of-place scatter-gather "
5152                                         "in both input and output mbufs.\n");
5153                         return TEST_SKIPPED;
5154                 }
5155                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5156                         printf("Device doesn't support digest encrypted.\n");
5157                         return TEST_SKIPPED;
5158                 }
5159         }
5160
5161         /* Create SNOW 3G session */
5162         retval = create_wireless_algo_auth_cipher_session(
5163                         ts_params->valid_devs[0],
5164                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5165                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5166                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5167                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5168                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5169                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5170                         tdata->key.data, tdata->key.len,
5171                         tdata->auth_iv.len, tdata->digest.len,
5172                         tdata->cipher_iv.len);
5173
5174         if (retval != 0)
5175                 return retval;
5176
5177         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5178         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5179         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5180         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5181
5182         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5183                         plaintext_pad_len, 15, 0);
5184         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5185                         "Failed to allocate input buffer in mempool");
5186
5187         if (op_mode == OUT_OF_PLACE) {
5188                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5189                                 plaintext_pad_len, 15, 0);
5190                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5191                                 "Failed to allocate output buffer in mempool");
5192         }
5193
5194         if (verify) {
5195                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5196                         tdata->ciphertext.data);
5197                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5198                                         ciphertext_len, buffer);
5199                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5200                         ciphertext_len);
5201         } else {
5202                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5203                         tdata->plaintext.data);
5204                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5205                                         plaintext_len, buffer);
5206                 debug_hexdump(stdout, "plaintext:", plaintext,
5207                         plaintext_len);
5208         }
5209         memset(buffer, 0, sizeof(buffer));
5210
5211         /* Create SNOW 3G operation */
5212         retval = create_wireless_algo_auth_cipher_operation(
5213                 tdata->digest.data, tdata->digest.len,
5214                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5215                 tdata->auth_iv.data, tdata->auth_iv.len,
5216                 (tdata->digest.offset_bytes == 0 ?
5217                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5218                         : tdata->digest.offset_bytes),
5219                 tdata->validCipherLenInBits.len,
5220                 tdata->cipher.offset_bits,
5221                 tdata->validAuthLenInBits.len,
5222                 tdata->auth.offset_bits,
5223                 op_mode, 1, verify);
5224
5225         if (retval < 0)
5226                 return retval;
5227
5228         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5229                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5230                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5231         else
5232                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5233                         ut_params->op);
5234
5235         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5236
5237         ut_params->obuf = (op_mode == IN_PLACE ?
5238                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5239
5240         if (verify) {
5241                 if (ut_params->obuf)
5242                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5243                                         plaintext_len, buffer);
5244                 else
5245                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5246                                         plaintext_len, buffer);
5247
5248                 debug_hexdump(stdout, "plaintext:", plaintext,
5249                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5250                 debug_hexdump(stdout, "plaintext expected:",
5251                         tdata->plaintext.data,
5252                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5253         } else {
5254                 if (ut_params->obuf)
5255                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5256                                         ciphertext_len, buffer);
5257                 else
5258                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5259                                         ciphertext_len, buffer);
5260
5261                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5262                         ciphertext_len);
5263                 debug_hexdump(stdout, "ciphertext expected:",
5264                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5265
5266                 if (ut_params->obuf)
5267                         digest = rte_pktmbuf_read(ut_params->obuf,
5268                                 (tdata->digest.offset_bytes == 0 ?
5269                                 plaintext_pad_len : tdata->digest.offset_bytes),
5270                                 tdata->digest.len, digest_buffer);
5271                 else
5272                         digest = rte_pktmbuf_read(ut_params->ibuf,
5273                                 (tdata->digest.offset_bytes == 0 ?
5274                                 plaintext_pad_len : tdata->digest.offset_bytes),
5275                                 tdata->digest.len, digest_buffer);
5276
5277                 debug_hexdump(stdout, "digest:", digest,
5278                         tdata->digest.len);
5279                 debug_hexdump(stdout, "digest expected:",
5280                         tdata->digest.data, tdata->digest.len);
5281         }
5282
5283         /* Validate obuf */
5284         if (verify) {
5285                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5286                         plaintext,
5287                         tdata->plaintext.data,
5288                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5289                          (tdata->digest.len << 3)),
5290                         tdata->cipher.offset_bits,
5291                         "SNOW 3G Plaintext data not as expected");
5292         } else {
5293                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5294                         ciphertext,
5295                         tdata->ciphertext.data,
5296                         (tdata->validDataLenInBits.len -
5297                          tdata->cipher.offset_bits),
5298                         tdata->cipher.offset_bits,
5299                         "SNOW 3G Ciphertext data not as expected");
5300
5301                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5302                         digest,
5303                         tdata->digest.data,
5304                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5305                         "SNOW 3G Generated auth tag not as expected");
5306         }
5307         return 0;
5308 }
5309
5310 static int
5311 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5312         uint8_t op_mode, uint8_t verify)
5313 {
5314         struct crypto_testsuite_params *ts_params = &testsuite_params;
5315         struct crypto_unittest_params *ut_params = &unittest_params;
5316
5317         int retval;
5318
5319         uint8_t *plaintext = NULL, *ciphertext = NULL;
5320         unsigned int plaintext_pad_len;
5321         unsigned int plaintext_len;
5322         unsigned int ciphertext_pad_len;
5323         unsigned int ciphertext_len;
5324
5325         struct rte_cryptodev_info dev_info;
5326
5327         /* Verify the capabilities */
5328         struct rte_cryptodev_sym_capability_idx cap_idx;
5329         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5330         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5331         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5332                         &cap_idx) == NULL)
5333                 return TEST_SKIPPED;
5334         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5335         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5336         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5337                         &cap_idx) == NULL)
5338                 return TEST_SKIPPED;
5339
5340         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5341
5342         uint64_t feat_flags = dev_info.feature_flags;
5343
5344         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5345                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5346                 printf("Device doesn't support RAW data-path APIs.\n");
5347                 return TEST_SKIPPED;
5348         }
5349
5350         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5351                 return TEST_SKIPPED;
5352
5353         if (op_mode == OUT_OF_PLACE) {
5354                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5355                         return TEST_SKIPPED;
5356                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5357                         printf("Device doesn't support digest encrypted.\n");
5358                         return TEST_SKIPPED;
5359                 }
5360         }
5361
5362         /* Create KASUMI session */
5363         retval = create_wireless_algo_auth_cipher_session(
5364                         ts_params->valid_devs[0],
5365                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5366                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5367                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5368                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5369                         RTE_CRYPTO_AUTH_KASUMI_F9,
5370                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5371                         tdata->key.data, tdata->key.len,
5372                         0, tdata->digest.len,
5373                         tdata->cipher_iv.len);
5374
5375         if (retval != 0)
5376                 return retval;
5377
5378         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5379         if (op_mode == OUT_OF_PLACE)
5380                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5381
5382         /* clear mbuf payload */
5383         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5384                 rte_pktmbuf_tailroom(ut_params->ibuf));
5385         if (op_mode == OUT_OF_PLACE)
5386                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5387                         rte_pktmbuf_tailroom(ut_params->obuf));
5388
5389         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5390         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5391         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5392         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5393
5394         if (verify) {
5395                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5396                                         ciphertext_pad_len);
5397                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5398                 if (op_mode == OUT_OF_PLACE)
5399                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5400                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5401                         ciphertext_len);
5402         } else {
5403                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5404                                         plaintext_pad_len);
5405                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5406                 if (op_mode == OUT_OF_PLACE)
5407                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5408                 debug_hexdump(stdout, "plaintext:", plaintext,
5409                         plaintext_len);
5410         }
5411
5412         /* Create KASUMI operation */
5413         retval = create_wireless_algo_auth_cipher_operation(
5414                 tdata->digest.data, tdata->digest.len,
5415                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5416                 NULL, 0,
5417                 (tdata->digest.offset_bytes == 0 ?
5418                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5419                         : tdata->digest.offset_bytes),
5420                 tdata->validCipherLenInBits.len,
5421                 tdata->validCipherOffsetInBits.len,
5422                 tdata->validAuthLenInBits.len,
5423                 0,
5424                 op_mode, 0, verify);
5425
5426         if (retval < 0)
5427                 return retval;
5428
5429         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5430                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5431                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5432         else
5433                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5434                         ut_params->op);
5435
5436         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5437
5438         ut_params->obuf = (op_mode == IN_PLACE ?
5439                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5440
5441
5442         if (verify) {
5443                 if (ut_params->obuf)
5444                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5445                                                         uint8_t *);
5446                 else
5447                         plaintext = ciphertext;
5448
5449                 debug_hexdump(stdout, "plaintext:", plaintext,
5450                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5451                 debug_hexdump(stdout, "plaintext expected:",
5452                         tdata->plaintext.data,
5453                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5454         } else {
5455                 if (ut_params->obuf)
5456                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5457                                                         uint8_t *);
5458                 else
5459                         ciphertext = plaintext;
5460
5461                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5462                         ciphertext_len);
5463                 debug_hexdump(stdout, "ciphertext expected:",
5464                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5465
5466                 ut_params->digest = rte_pktmbuf_mtod(
5467                         ut_params->obuf, uint8_t *) +
5468                         (tdata->digest.offset_bytes == 0 ?
5469                         plaintext_pad_len : tdata->digest.offset_bytes);
5470
5471                 debug_hexdump(stdout, "digest:", ut_params->digest,
5472                         tdata->digest.len);
5473                 debug_hexdump(stdout, "digest expected:",
5474                         tdata->digest.data, tdata->digest.len);
5475         }
5476
5477         /* Validate obuf */
5478         if (verify) {
5479                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5480                         plaintext,
5481                         tdata->plaintext.data,
5482                         tdata->plaintext.len >> 3,
5483                         "KASUMI Plaintext data not as expected");
5484         } else {
5485                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5486                         ciphertext,
5487                         tdata->ciphertext.data,
5488                         tdata->ciphertext.len >> 3,
5489                         "KASUMI Ciphertext data not as expected");
5490
5491                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5492                         ut_params->digest,
5493                         tdata->digest.data,
5494                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5495                         "KASUMI Generated auth tag not as expected");
5496         }
5497         return 0;
5498 }
5499
5500 static int
5501 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5502         uint8_t op_mode, uint8_t verify)
5503 {
5504         struct crypto_testsuite_params *ts_params = &testsuite_params;
5505         struct crypto_unittest_params *ut_params = &unittest_params;
5506
5507         int retval;
5508
5509         const uint8_t *plaintext = NULL;
5510         const uint8_t *ciphertext = NULL;
5511         const uint8_t *digest = NULL;
5512         unsigned int plaintext_pad_len;
5513         unsigned int plaintext_len;
5514         unsigned int ciphertext_pad_len;
5515         unsigned int ciphertext_len;
5516         uint8_t buffer[10000];
5517         uint8_t digest_buffer[10000];
5518
5519         struct rte_cryptodev_info dev_info;
5520
5521         /* Verify the capabilities */
5522         struct rte_cryptodev_sym_capability_idx cap_idx;
5523         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5524         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5525         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5526                         &cap_idx) == NULL)
5527                 return TEST_SKIPPED;
5528         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5529         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5530         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5531                         &cap_idx) == NULL)
5532                 return TEST_SKIPPED;
5533
5534         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5535                 return TEST_SKIPPED;
5536
5537         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5538
5539         uint64_t feat_flags = dev_info.feature_flags;
5540
5541         if (op_mode == IN_PLACE) {
5542                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5543                         printf("Device doesn't support in-place scatter-gather "
5544                                         "in both input and output mbufs.\n");
5545                         return TEST_SKIPPED;
5546                 }
5547                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5548                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5549                         printf("Device doesn't support RAW data-path APIs.\n");
5550                         return TEST_SKIPPED;
5551                 }
5552         } else {
5553                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5554                         return TEST_SKIPPED;
5555                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5556                         printf("Device doesn't support out-of-place scatter-gather "
5557                                         "in both input and output mbufs.\n");
5558                         return TEST_SKIPPED;
5559                 }
5560                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5561                         printf("Device doesn't support digest encrypted.\n");
5562                         return TEST_SKIPPED;
5563                 }
5564         }
5565
5566         /* Create KASUMI session */
5567         retval = create_wireless_algo_auth_cipher_session(
5568                         ts_params->valid_devs[0],
5569                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5570                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5571                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5572                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5573                         RTE_CRYPTO_AUTH_KASUMI_F9,
5574                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5575                         tdata->key.data, tdata->key.len,
5576                         0, tdata->digest.len,
5577                         tdata->cipher_iv.len);
5578
5579         if (retval != 0)
5580                 return retval;
5581
5582         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5583         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5584         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5585         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5586
5587         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5588                         plaintext_pad_len, 15, 0);
5589         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5590                         "Failed to allocate input buffer in mempool");
5591
5592         if (op_mode == OUT_OF_PLACE) {
5593                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5594                                 plaintext_pad_len, 15, 0);
5595                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5596                                 "Failed to allocate output buffer in mempool");
5597         }
5598
5599         if (verify) {
5600                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5601                         tdata->ciphertext.data);
5602                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5603                                         ciphertext_len, buffer);
5604                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5605                         ciphertext_len);
5606         } else {
5607                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5608                         tdata->plaintext.data);
5609                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5610                                         plaintext_len, buffer);
5611                 debug_hexdump(stdout, "plaintext:", plaintext,
5612                         plaintext_len);
5613         }
5614         memset(buffer, 0, sizeof(buffer));
5615
5616         /* Create KASUMI operation */
5617         retval = create_wireless_algo_auth_cipher_operation(
5618                 tdata->digest.data, tdata->digest.len,
5619                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5620                 NULL, 0,
5621                 (tdata->digest.offset_bytes == 0 ?
5622                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5623                         : tdata->digest.offset_bytes),
5624                 tdata->validCipherLenInBits.len,
5625                 tdata->validCipherOffsetInBits.len,
5626                 tdata->validAuthLenInBits.len,
5627                 0,
5628                 op_mode, 1, verify);
5629
5630         if (retval < 0)
5631                 return retval;
5632
5633         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5634                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5635                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5636         else
5637                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5638                         ut_params->op);
5639
5640         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5641
5642         ut_params->obuf = (op_mode == IN_PLACE ?
5643                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5644
5645         if (verify) {
5646                 if (ut_params->obuf)
5647                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5648                                         plaintext_len, buffer);
5649                 else
5650                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5651                                         plaintext_len, buffer);
5652
5653                 debug_hexdump(stdout, "plaintext:", plaintext,
5654                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5655                 debug_hexdump(stdout, "plaintext expected:",
5656                         tdata->plaintext.data,
5657                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5658         } else {
5659                 if (ut_params->obuf)
5660                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5661                                         ciphertext_len, buffer);
5662                 else
5663                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5664                                         ciphertext_len, buffer);
5665
5666                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5667                         ciphertext_len);
5668                 debug_hexdump(stdout, "ciphertext expected:",
5669                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5670
5671                 if (ut_params->obuf)
5672                         digest = rte_pktmbuf_read(ut_params->obuf,
5673                                 (tdata->digest.offset_bytes == 0 ?
5674                                 plaintext_pad_len : tdata->digest.offset_bytes),
5675                                 tdata->digest.len, digest_buffer);
5676                 else
5677                         digest = rte_pktmbuf_read(ut_params->ibuf,
5678                                 (tdata->digest.offset_bytes == 0 ?
5679                                 plaintext_pad_len : tdata->digest.offset_bytes),
5680                                 tdata->digest.len, digest_buffer);
5681
5682                 debug_hexdump(stdout, "digest:", digest,
5683                         tdata->digest.len);
5684                 debug_hexdump(stdout, "digest expected:",
5685                         tdata->digest.data, tdata->digest.len);
5686         }
5687
5688         /* Validate obuf */
5689         if (verify) {
5690                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5691                         plaintext,
5692                         tdata->plaintext.data,
5693                         tdata->plaintext.len >> 3,
5694                         "KASUMI Plaintext data not as expected");
5695         } else {
5696                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5697                         ciphertext,
5698                         tdata->ciphertext.data,
5699                         tdata->validDataLenInBits.len,
5700                         "KASUMI Ciphertext data not as expected");
5701
5702                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5703                         digest,
5704                         tdata->digest.data,
5705                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5706                         "KASUMI Generated auth tag not as expected");
5707         }
5708         return 0;
5709 }
5710
5711 static int
5712 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5713 {
5714         struct crypto_testsuite_params *ts_params = &testsuite_params;
5715         struct crypto_unittest_params *ut_params = &unittest_params;
5716
5717         int retval;
5718
5719         uint8_t *plaintext, *ciphertext;
5720         unsigned plaintext_pad_len;
5721         unsigned plaintext_len;
5722         struct rte_cryptodev_info dev_info;
5723
5724         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5725         uint64_t feat_flags = dev_info.feature_flags;
5726
5727         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5728                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5729                 printf("Device doesn't support RAW data-path APIs.\n");
5730                 return TEST_SKIPPED;
5731         }
5732
5733         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5734                 return TEST_SKIPPED;
5735
5736         /* Verify the capabilities */
5737         struct rte_cryptodev_sym_capability_idx cap_idx;
5738         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5739         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5740         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5741                         &cap_idx) == NULL)
5742                 return TEST_SKIPPED;
5743         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5744         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5745         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5746                         &cap_idx) == NULL)
5747                 return TEST_SKIPPED;
5748
5749         /* Create KASUMI session */
5750         retval = create_wireless_algo_cipher_auth_session(
5751                         ts_params->valid_devs[0],
5752                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5753                         RTE_CRYPTO_AUTH_OP_GENERATE,
5754                         RTE_CRYPTO_AUTH_KASUMI_F9,
5755                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5756                         tdata->key.data, tdata->key.len,
5757                         0, tdata->digest.len,
5758                         tdata->cipher_iv.len);
5759         if (retval != 0)
5760                 return retval;
5761
5762         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5763
5764         /* clear mbuf payload */
5765         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5766                         rte_pktmbuf_tailroom(ut_params->ibuf));
5767
5768         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5769         /* Append data which is padded to a multiple of */
5770         /* the algorithms block size */
5771         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5772         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5773                                 plaintext_pad_len);
5774         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5775
5776         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5777
5778         /* Create KASUMI operation */
5779         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5780                                 tdata->digest.len, NULL, 0,
5781                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5782                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5783                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5784                                 tdata->validCipherOffsetInBits.len,
5785                                 tdata->validAuthLenInBits.len,
5786                                 0
5787                                 );
5788         if (retval < 0)
5789                 return retval;
5790
5791         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5792                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5793                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5794         else
5795                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5796                         ut_params->op);
5797         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5798
5799         if (ut_params->op->sym->m_dst)
5800                 ut_params->obuf = ut_params->op->sym->m_dst;
5801         else
5802                 ut_params->obuf = ut_params->op->sym->m_src;
5803
5804         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5805                                 tdata->validCipherOffsetInBits.len >> 3);
5806
5807         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5808                         + plaintext_pad_len;
5809
5810         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5811                                 (tdata->validCipherOffsetInBits.len >> 3);
5812         /* Validate obuf */
5813         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5814                 ciphertext,
5815                 reference_ciphertext,
5816                 tdata->validCipherLenInBits.len,
5817                 "KASUMI Ciphertext data not as expected");
5818
5819         /* Validate obuf */
5820         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5821                 ut_params->digest,
5822                 tdata->digest.data,
5823                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5824                 "KASUMI Generated auth tag not as expected");
5825         return 0;
5826 }
5827
5828 static int
5829 test_zuc_encryption(const struct wireless_test_data *tdata)
5830 {
5831         struct crypto_testsuite_params *ts_params = &testsuite_params;
5832         struct crypto_unittest_params *ut_params = &unittest_params;
5833
5834         int retval;
5835         uint8_t *plaintext, *ciphertext;
5836         unsigned plaintext_pad_len;
5837         unsigned plaintext_len;
5838         struct rte_cryptodev_info dev_info;
5839
5840         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5841         uint64_t feat_flags = dev_info.feature_flags;
5842
5843         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5844                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5845                 printf("Device doesn't support RAW data-path APIs.\n");
5846                 return TEST_SKIPPED;
5847         }
5848
5849         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5850                 return TEST_SKIPPED;
5851
5852         struct rte_cryptodev_sym_capability_idx cap_idx;
5853
5854         /* Check if device supports ZUC EEA3 */
5855         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5856         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5857
5858         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5859                         &cap_idx) == NULL)
5860                 return TEST_SKIPPED;
5861
5862         /* Create ZUC session */
5863         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5864                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5865                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5866                                         tdata->key.data, tdata->key.len,
5867                                         tdata->cipher_iv.len);
5868         if (retval != 0)
5869                 return retval;
5870
5871         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5872
5873         /* Clear mbuf payload */
5874         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5875                rte_pktmbuf_tailroom(ut_params->ibuf));
5876
5877         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5878         /* Append data which is padded to a multiple */
5879         /* of the algorithms block size */
5880         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5881         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5882                                 plaintext_pad_len);
5883         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5884
5885         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5886
5887         /* Create ZUC operation */
5888         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5889                                         tdata->cipher_iv.len,
5890                                         tdata->plaintext.len,
5891                                         0);
5892         if (retval < 0)
5893                 return retval;
5894
5895         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5896                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5897                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5898         else
5899                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5900                                                 ut_params->op);
5901         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5902
5903         ut_params->obuf = ut_params->op->sym->m_dst;
5904         if (ut_params->obuf)
5905                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5906         else
5907                 ciphertext = plaintext;
5908
5909         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5910
5911         /* Validate obuf */
5912         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5913                 ciphertext,
5914                 tdata->ciphertext.data,
5915                 tdata->validCipherLenInBits.len,
5916                 "ZUC Ciphertext data not as expected");
5917         return 0;
5918 }
5919
5920 static int
5921 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5922 {
5923         struct crypto_testsuite_params *ts_params = &testsuite_params;
5924         struct crypto_unittest_params *ut_params = &unittest_params;
5925
5926         int retval;
5927
5928         unsigned int plaintext_pad_len;
5929         unsigned int plaintext_len;
5930         const uint8_t *ciphertext;
5931         uint8_t ciphertext_buffer[2048];
5932         struct rte_cryptodev_info dev_info;
5933
5934         struct rte_cryptodev_sym_capability_idx cap_idx;
5935
5936         /* Check if device supports ZUC EEA3 */
5937         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5938         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5939
5940         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5941                         &cap_idx) == NULL)
5942                 return TEST_SKIPPED;
5943
5944         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5945                 return TEST_SKIPPED;
5946
5947         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5948
5949         uint64_t feat_flags = dev_info.feature_flags;
5950
5951         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5952                 printf("Device doesn't support in-place scatter-gather. "
5953                                 "Test Skipped.\n");
5954                 return TEST_SKIPPED;
5955         }
5956
5957         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5958                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5959                 printf("Device doesn't support RAW data-path APIs.\n");
5960                 return TEST_SKIPPED;
5961         }
5962
5963         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5964
5965         /* Append data which is padded to a multiple */
5966         /* of the algorithms block size */
5967         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5968
5969         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5970                         plaintext_pad_len, 10, 0);
5971
5972         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5973                         tdata->plaintext.data);
5974
5975         /* Create ZUC session */
5976         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5977                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5978                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5979                         tdata->key.data, tdata->key.len,
5980                         tdata->cipher_iv.len);
5981         if (retval < 0)
5982                 return retval;
5983
5984         /* Clear mbuf payload */
5985
5986         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5987
5988         /* Create ZUC operation */
5989         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5990                         tdata->cipher_iv.len, tdata->plaintext.len,
5991                         0);
5992         if (retval < 0)
5993                 return retval;
5994
5995         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5996                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5997                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5998         else
5999                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6000                                                 ut_params->op);
6001         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6002
6003         ut_params->obuf = ut_params->op->sym->m_dst;
6004         if (ut_params->obuf)
6005                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6006                         0, plaintext_len, ciphertext_buffer);
6007         else
6008                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6009                         0, plaintext_len, ciphertext_buffer);
6010
6011         /* Validate obuf */
6012         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6013
6014         /* Validate obuf */
6015         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6016                 ciphertext,
6017                 tdata->ciphertext.data,
6018                 tdata->validCipherLenInBits.len,
6019                 "ZUC Ciphertext data not as expected");
6020
6021         return 0;
6022 }
6023
6024 static int
6025 test_zuc_authentication(const struct wireless_test_data *tdata)
6026 {
6027         struct crypto_testsuite_params *ts_params = &testsuite_params;
6028         struct crypto_unittest_params *ut_params = &unittest_params;
6029
6030         int retval;
6031         unsigned plaintext_pad_len;
6032         unsigned plaintext_len;
6033         uint8_t *plaintext;
6034
6035         struct rte_cryptodev_sym_capability_idx cap_idx;
6036         struct rte_cryptodev_info dev_info;
6037
6038         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6039         uint64_t feat_flags = dev_info.feature_flags;
6040
6041         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6042                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6043                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6044                 return TEST_SKIPPED;
6045         }
6046
6047         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6048                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6049                 printf("Device doesn't support RAW data-path APIs.\n");
6050                 return TEST_SKIPPED;
6051         }
6052
6053         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6054                 return TEST_SKIPPED;
6055
6056         /* Check if device supports ZUC EIA3 */
6057         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6058         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6059
6060         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6061                         &cap_idx) == NULL)
6062                 return TEST_SKIPPED;
6063
6064         /* Create ZUC session */
6065         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6066                         tdata->key.data, tdata->key.len,
6067                         tdata->auth_iv.len, tdata->digest.len,
6068                         RTE_CRYPTO_AUTH_OP_GENERATE,
6069                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6070         if (retval != 0)
6071                 return retval;
6072
6073         /* alloc mbuf and set payload */
6074         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6075
6076         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6077         rte_pktmbuf_tailroom(ut_params->ibuf));
6078
6079         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6080         /* Append data which is padded to a multiple of */
6081         /* the algorithms block size */
6082         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6083         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6084                                 plaintext_pad_len);
6085         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6086
6087         /* Create ZUC operation */
6088         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6089                         tdata->auth_iv.data, tdata->auth_iv.len,
6090                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6091                         tdata->validAuthLenInBits.len,
6092                         0);
6093         if (retval < 0)
6094                 return retval;
6095
6096         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6097                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6098                                 ut_params->op, 0, 1, 1, 0);
6099         else
6100                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6101                                 ut_params->op);
6102         ut_params->obuf = ut_params->op->sym->m_src;
6103         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6104         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6105                         + plaintext_pad_len;
6106
6107         /* Validate obuf */
6108         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6109         ut_params->digest,
6110         tdata->digest.data,
6111         tdata->digest.len,
6112         "ZUC Generated auth tag not as expected");
6113
6114         return 0;
6115 }
6116
6117 static int
6118 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6119         uint8_t op_mode, uint8_t verify)
6120 {
6121         struct crypto_testsuite_params *ts_params = &testsuite_params;
6122         struct crypto_unittest_params *ut_params = &unittest_params;
6123
6124         int retval;
6125
6126         uint8_t *plaintext = NULL, *ciphertext = NULL;
6127         unsigned int plaintext_pad_len;
6128         unsigned int plaintext_len;
6129         unsigned int ciphertext_pad_len;
6130         unsigned int ciphertext_len;
6131
6132         struct rte_cryptodev_info dev_info;
6133         struct rte_cryptodev_sym_capability_idx cap_idx;
6134
6135         /* Check if device supports ZUC EIA3 */
6136         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6137         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6138
6139         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6140                         &cap_idx) == NULL)
6141                 return TEST_SKIPPED;
6142
6143         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6144
6145         uint64_t feat_flags = dev_info.feature_flags;
6146
6147         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6148                 printf("Device doesn't support digest encrypted.\n");
6149                 return TEST_SKIPPED;
6150         }
6151         if (op_mode == IN_PLACE) {
6152                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6153                         printf("Device doesn't support in-place scatter-gather "
6154                                         "in both input and output mbufs.\n");
6155                         return TEST_SKIPPED;
6156                 }
6157
6158                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6159                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6160                         printf("Device doesn't support RAW data-path APIs.\n");
6161                         return TEST_SKIPPED;
6162                 }
6163         } else {
6164                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6165                         return TEST_SKIPPED;
6166                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6167                         printf("Device doesn't support out-of-place scatter-gather "
6168                                         "in both input and output mbufs.\n");
6169                         return TEST_SKIPPED;
6170                 }
6171         }
6172
6173         /* Create ZUC session */
6174         retval = create_wireless_algo_auth_cipher_session(
6175                         ts_params->valid_devs[0],
6176                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6177                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6178                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6179                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6180                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6181                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6182                         tdata->key.data, tdata->key.len,
6183                         tdata->auth_iv.len, tdata->digest.len,
6184                         tdata->cipher_iv.len);
6185
6186         if (retval != 0)
6187                 return retval;
6188
6189         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6190         if (op_mode == OUT_OF_PLACE)
6191                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6192
6193         /* clear mbuf payload */
6194         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6195                 rte_pktmbuf_tailroom(ut_params->ibuf));
6196         if (op_mode == OUT_OF_PLACE)
6197                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6198                         rte_pktmbuf_tailroom(ut_params->obuf));
6199
6200         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6201         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6202         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6203         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6204
6205         if (verify) {
6206                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6207                                         ciphertext_pad_len);
6208                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6209                 if (op_mode == OUT_OF_PLACE)
6210                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6211                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6212                         ciphertext_len);
6213         } else {
6214                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6215                                         plaintext_pad_len);
6216                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6217                 if (op_mode == OUT_OF_PLACE)
6218                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6219                 debug_hexdump(stdout, "plaintext:", plaintext,
6220                         plaintext_len);
6221         }
6222
6223         /* Create ZUC operation */
6224         retval = create_wireless_algo_auth_cipher_operation(
6225                 tdata->digest.data, tdata->digest.len,
6226                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6227                 tdata->auth_iv.data, tdata->auth_iv.len,
6228                 (tdata->digest.offset_bytes == 0 ?
6229                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6230                         : tdata->digest.offset_bytes),
6231                 tdata->validCipherLenInBits.len,
6232                 tdata->validCipherOffsetInBits.len,
6233                 tdata->validAuthLenInBits.len,
6234                 0,
6235                 op_mode, 0, verify);
6236
6237         if (retval < 0)
6238                 return retval;
6239
6240         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6241                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6242                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6243         else
6244                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6245                         ut_params->op);
6246
6247         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6248
6249         ut_params->obuf = (op_mode == IN_PLACE ?
6250                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6251
6252
6253         if (verify) {
6254                 if (ut_params->obuf)
6255                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6256                                                         uint8_t *);
6257                 else
6258                         plaintext = ciphertext;
6259
6260                 debug_hexdump(stdout, "plaintext:", plaintext,
6261                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6262                 debug_hexdump(stdout, "plaintext expected:",
6263                         tdata->plaintext.data,
6264                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6265         } else {
6266                 if (ut_params->obuf)
6267                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6268                                                         uint8_t *);
6269                 else
6270                         ciphertext = plaintext;
6271
6272                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6273                         ciphertext_len);
6274                 debug_hexdump(stdout, "ciphertext expected:",
6275                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6276
6277                 ut_params->digest = rte_pktmbuf_mtod(
6278                         ut_params->obuf, uint8_t *) +
6279                         (tdata->digest.offset_bytes == 0 ?
6280                         plaintext_pad_len : tdata->digest.offset_bytes);
6281
6282                 debug_hexdump(stdout, "digest:", ut_params->digest,
6283                         tdata->digest.len);
6284                 debug_hexdump(stdout, "digest expected:",
6285                         tdata->digest.data, tdata->digest.len);
6286         }
6287
6288         /* Validate obuf */
6289         if (verify) {
6290                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6291                         plaintext,
6292                         tdata->plaintext.data,
6293                         tdata->plaintext.len >> 3,
6294                         "ZUC Plaintext data not as expected");
6295         } else {
6296                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6297                         ciphertext,
6298                         tdata->ciphertext.data,
6299                         tdata->ciphertext.len >> 3,
6300                         "ZUC Ciphertext data not as expected");
6301
6302                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6303                         ut_params->digest,
6304                         tdata->digest.data,
6305                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6306                         "ZUC Generated auth tag not as expected");
6307         }
6308         return 0;
6309 }
6310
6311 static int
6312 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6313         uint8_t op_mode, uint8_t verify)
6314 {
6315         struct crypto_testsuite_params *ts_params = &testsuite_params;
6316         struct crypto_unittest_params *ut_params = &unittest_params;
6317
6318         int retval;
6319
6320         const uint8_t *plaintext = NULL;
6321         const uint8_t *ciphertext = NULL;
6322         const uint8_t *digest = NULL;
6323         unsigned int plaintext_pad_len;
6324         unsigned int plaintext_len;
6325         unsigned int ciphertext_pad_len;
6326         unsigned int ciphertext_len;
6327         uint8_t buffer[10000];
6328         uint8_t digest_buffer[10000];
6329
6330         struct rte_cryptodev_info dev_info;
6331         struct rte_cryptodev_sym_capability_idx cap_idx;
6332
6333         /* Check if device supports ZUC EIA3 */
6334         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6335         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
6336
6337         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
6338                         &cap_idx) == NULL)
6339                 return TEST_SKIPPED;
6340
6341         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6342
6343         uint64_t feat_flags = dev_info.feature_flags;
6344
6345         if (op_mode == IN_PLACE) {
6346                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6347                         printf("Device doesn't support in-place scatter-gather "
6348                                         "in both input and output mbufs.\n");
6349                         return TEST_SKIPPED;
6350                 }
6351
6352                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6353                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6354                         printf("Device doesn't support RAW data-path APIs.\n");
6355                         return TEST_SKIPPED;
6356                 }
6357         } else {
6358                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6359                         return TEST_SKIPPED;
6360                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6361                         printf("Device doesn't support out-of-place scatter-gather "
6362                                         "in both input and output mbufs.\n");
6363                         return TEST_SKIPPED;
6364                 }
6365                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6366                         printf("Device doesn't support digest encrypted.\n");
6367                         return TEST_SKIPPED;
6368                 }
6369         }
6370
6371         /* Create ZUC session */
6372         retval = create_wireless_algo_auth_cipher_session(
6373                         ts_params->valid_devs[0],
6374                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6375                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6376                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6377                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6378                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6379                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6380                         tdata->key.data, tdata->key.len,
6381                         tdata->auth_iv.len, tdata->digest.len,
6382                         tdata->cipher_iv.len);
6383
6384         if (retval != 0)
6385                 return retval;
6386
6387         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6388         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6389         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6390         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6391
6392         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6393                         plaintext_pad_len, 15, 0);
6394         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6395                         "Failed to allocate input buffer in mempool");
6396
6397         if (op_mode == OUT_OF_PLACE) {
6398                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6399                                 plaintext_pad_len, 15, 0);
6400                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6401                                 "Failed to allocate output buffer in mempool");
6402         }
6403
6404         if (verify) {
6405                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6406                         tdata->ciphertext.data);
6407                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6408                                         ciphertext_len, buffer);
6409                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6410                         ciphertext_len);
6411         } else {
6412                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6413                         tdata->plaintext.data);
6414                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6415                                         plaintext_len, buffer);
6416                 debug_hexdump(stdout, "plaintext:", plaintext,
6417                         plaintext_len);
6418         }
6419         memset(buffer, 0, sizeof(buffer));
6420
6421         /* Create ZUC operation */
6422         retval = create_wireless_algo_auth_cipher_operation(
6423                 tdata->digest.data, tdata->digest.len,
6424                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6425                 NULL, 0,
6426                 (tdata->digest.offset_bytes == 0 ?
6427                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6428                         : tdata->digest.offset_bytes),
6429                 tdata->validCipherLenInBits.len,
6430                 tdata->validCipherOffsetInBits.len,
6431                 tdata->validAuthLenInBits.len,
6432                 0,
6433                 op_mode, 1, verify);
6434
6435         if (retval < 0)
6436                 return retval;
6437
6438         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6439                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6440                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6441         else
6442                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6443                         ut_params->op);
6444
6445         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6446
6447         ut_params->obuf = (op_mode == IN_PLACE ?
6448                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6449
6450         if (verify) {
6451                 if (ut_params->obuf)
6452                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6453                                         plaintext_len, buffer);
6454                 else
6455                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6456                                         plaintext_len, buffer);
6457
6458                 debug_hexdump(stdout, "plaintext:", plaintext,
6459                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6460                 debug_hexdump(stdout, "plaintext expected:",
6461                         tdata->plaintext.data,
6462                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6463         } else {
6464                 if (ut_params->obuf)
6465                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6466                                         ciphertext_len, buffer);
6467                 else
6468                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6469                                         ciphertext_len, buffer);
6470
6471                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6472                         ciphertext_len);
6473                 debug_hexdump(stdout, "ciphertext expected:",
6474                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6475
6476                 if (ut_params->obuf)
6477                         digest = rte_pktmbuf_read(ut_params->obuf,
6478                                 (tdata->digest.offset_bytes == 0 ?
6479                                 plaintext_pad_len : tdata->digest.offset_bytes),
6480                                 tdata->digest.len, digest_buffer);
6481                 else
6482                         digest = rte_pktmbuf_read(ut_params->ibuf,
6483                                 (tdata->digest.offset_bytes == 0 ?
6484                                 plaintext_pad_len : tdata->digest.offset_bytes),
6485                                 tdata->digest.len, digest_buffer);
6486
6487                 debug_hexdump(stdout, "digest:", digest,
6488                         tdata->digest.len);
6489                 debug_hexdump(stdout, "digest expected:",
6490                         tdata->digest.data, tdata->digest.len);
6491         }
6492
6493         /* Validate obuf */
6494         if (verify) {
6495                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6496                         plaintext,
6497                         tdata->plaintext.data,
6498                         tdata->plaintext.len >> 3,
6499                         "ZUC Plaintext data not as expected");
6500         } else {
6501                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6502                         ciphertext,
6503                         tdata->ciphertext.data,
6504                         tdata->validDataLenInBits.len,
6505                         "ZUC Ciphertext data not as expected");
6506
6507                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6508                         digest,
6509                         tdata->digest.data,
6510                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6511                         "ZUC Generated auth tag not as expected");
6512         }
6513         return 0;
6514 }
6515
6516 static int
6517 test_kasumi_encryption_test_case_1(void)
6518 {
6519         return test_kasumi_encryption(&kasumi_test_case_1);
6520 }
6521
6522 static int
6523 test_kasumi_encryption_test_case_1_sgl(void)
6524 {
6525         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6526 }
6527
6528 static int
6529 test_kasumi_encryption_test_case_1_oop(void)
6530 {
6531         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6532 }
6533
6534 static int
6535 test_kasumi_encryption_test_case_1_oop_sgl(void)
6536 {
6537         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6538 }
6539
6540 static int
6541 test_kasumi_encryption_test_case_2(void)
6542 {
6543         return test_kasumi_encryption(&kasumi_test_case_2);
6544 }
6545
6546 static int
6547 test_kasumi_encryption_test_case_3(void)
6548 {
6549         return test_kasumi_encryption(&kasumi_test_case_3);
6550 }
6551
6552 static int
6553 test_kasumi_encryption_test_case_4(void)
6554 {
6555         return test_kasumi_encryption(&kasumi_test_case_4);
6556 }
6557
6558 static int
6559 test_kasumi_encryption_test_case_5(void)
6560 {
6561         return test_kasumi_encryption(&kasumi_test_case_5);
6562 }
6563
6564 static int
6565 test_kasumi_decryption_test_case_1(void)
6566 {
6567         return test_kasumi_decryption(&kasumi_test_case_1);
6568 }
6569
6570 static int
6571 test_kasumi_decryption_test_case_1_oop(void)
6572 {
6573         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6574 }
6575
6576 static int
6577 test_kasumi_decryption_test_case_2(void)
6578 {
6579         return test_kasumi_decryption(&kasumi_test_case_2);
6580 }
6581
6582 static int
6583 test_kasumi_decryption_test_case_3(void)
6584 {
6585         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6586         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6587                 return TEST_SKIPPED;
6588         return test_kasumi_decryption(&kasumi_test_case_3);
6589 }
6590
6591 static int
6592 test_kasumi_decryption_test_case_4(void)
6593 {
6594         return test_kasumi_decryption(&kasumi_test_case_4);
6595 }
6596
6597 static int
6598 test_kasumi_decryption_test_case_5(void)
6599 {
6600         return test_kasumi_decryption(&kasumi_test_case_5);
6601 }
6602 static int
6603 test_snow3g_encryption_test_case_1(void)
6604 {
6605         return test_snow3g_encryption(&snow3g_test_case_1);
6606 }
6607
6608 static int
6609 test_snow3g_encryption_test_case_1_oop(void)
6610 {
6611         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6612 }
6613
6614 static int
6615 test_snow3g_encryption_test_case_1_oop_sgl(void)
6616 {
6617         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6618 }
6619
6620
6621 static int
6622 test_snow3g_encryption_test_case_1_offset_oop(void)
6623 {
6624         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6625 }
6626
6627 static int
6628 test_snow3g_encryption_test_case_2(void)
6629 {
6630         return test_snow3g_encryption(&snow3g_test_case_2);
6631 }
6632
6633 static int
6634 test_snow3g_encryption_test_case_3(void)
6635 {
6636         return test_snow3g_encryption(&snow3g_test_case_3);
6637 }
6638
6639 static int
6640 test_snow3g_encryption_test_case_4(void)
6641 {
6642         return test_snow3g_encryption(&snow3g_test_case_4);
6643 }
6644
6645 static int
6646 test_snow3g_encryption_test_case_5(void)
6647 {
6648         return test_snow3g_encryption(&snow3g_test_case_5);
6649 }
6650
6651 static int
6652 test_snow3g_decryption_test_case_1(void)
6653 {
6654         return test_snow3g_decryption(&snow3g_test_case_1);
6655 }
6656
6657 static int
6658 test_snow3g_decryption_test_case_1_oop(void)
6659 {
6660         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6661 }
6662
6663 static int
6664 test_snow3g_decryption_test_case_2(void)
6665 {
6666         return test_snow3g_decryption(&snow3g_test_case_2);
6667 }
6668
6669 static int
6670 test_snow3g_decryption_test_case_3(void)
6671 {
6672         return test_snow3g_decryption(&snow3g_test_case_3);
6673 }
6674
6675 static int
6676 test_snow3g_decryption_test_case_4(void)
6677 {
6678         return test_snow3g_decryption(&snow3g_test_case_4);
6679 }
6680
6681 static int
6682 test_snow3g_decryption_test_case_5(void)
6683 {
6684         return test_snow3g_decryption(&snow3g_test_case_5);
6685 }
6686
6687 /*
6688  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6689  * Pattern digest from snow3g_test_data must be allocated as
6690  * 4 last bytes in plaintext.
6691  */
6692 static void
6693 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6694                 struct snow3g_hash_test_data *output)
6695 {
6696         if ((pattern != NULL) && (output != NULL)) {
6697                 output->key.len = pattern->key.len;
6698
6699                 memcpy(output->key.data,
6700                 pattern->key.data, pattern->key.len);
6701
6702                 output->auth_iv.len = pattern->auth_iv.len;
6703
6704                 memcpy(output->auth_iv.data,
6705                 pattern->auth_iv.data, pattern->auth_iv.len);
6706
6707                 output->plaintext.len = pattern->plaintext.len;
6708
6709                 memcpy(output->plaintext.data,
6710                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6711
6712                 output->digest.len = pattern->digest.len;
6713
6714                 memcpy(output->digest.data,
6715                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6716                 pattern->digest.len);
6717
6718                 output->validAuthLenInBits.len =
6719                 pattern->validAuthLenInBits.len;
6720         }
6721 }
6722
6723 /*
6724  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6725  */
6726 static int
6727 test_snow3g_decryption_with_digest_test_case_1(void)
6728 {
6729         struct snow3g_hash_test_data snow3g_hash_data;
6730         struct rte_cryptodev_info dev_info;
6731         struct crypto_testsuite_params *ts_params = &testsuite_params;
6732
6733         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6734         uint64_t feat_flags = dev_info.feature_flags;
6735
6736         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6737                 printf("Device doesn't support encrypted digest operations.\n");
6738                 return TEST_SKIPPED;
6739         }
6740
6741         /*
6742          * Function prepare data for hash veryfication test case.
6743          * Digest is allocated in 4 last bytes in plaintext, pattern.
6744          */
6745         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6746
6747         return test_snow3g_decryption(&snow3g_test_case_7) &
6748                         test_snow3g_authentication_verify(&snow3g_hash_data);
6749 }
6750
6751 static int
6752 test_snow3g_cipher_auth_test_case_1(void)
6753 {
6754         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6755 }
6756
6757 static int
6758 test_snow3g_auth_cipher_test_case_1(void)
6759 {
6760         return test_snow3g_auth_cipher(
6761                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6762 }
6763
6764 static int
6765 test_snow3g_auth_cipher_test_case_2(void)
6766 {
6767         return test_snow3g_auth_cipher(
6768                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6769 }
6770
6771 static int
6772 test_snow3g_auth_cipher_test_case_2_oop(void)
6773 {
6774         return test_snow3g_auth_cipher(
6775                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6776 }
6777
6778 static int
6779 test_snow3g_auth_cipher_part_digest_enc(void)
6780 {
6781         return test_snow3g_auth_cipher(
6782                 &snow3g_auth_cipher_partial_digest_encryption,
6783                         IN_PLACE, 0);
6784 }
6785
6786 static int
6787 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6788 {
6789         return test_snow3g_auth_cipher(
6790                 &snow3g_auth_cipher_partial_digest_encryption,
6791                         OUT_OF_PLACE, 0);
6792 }
6793
6794 static int
6795 test_snow3g_auth_cipher_test_case_3_sgl(void)
6796 {
6797         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6798         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6799                 return TEST_SKIPPED;
6800         return test_snow3g_auth_cipher_sgl(
6801                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6802 }
6803
6804 static int
6805 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6806 {
6807         return test_snow3g_auth_cipher_sgl(
6808                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6809 }
6810
6811 static int
6812 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6813 {
6814         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6815         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6816                 return TEST_SKIPPED;
6817         return test_snow3g_auth_cipher_sgl(
6818                 &snow3g_auth_cipher_partial_digest_encryption,
6819                         IN_PLACE, 0);
6820 }
6821
6822 static int
6823 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6824 {
6825         return test_snow3g_auth_cipher_sgl(
6826                 &snow3g_auth_cipher_partial_digest_encryption,
6827                         OUT_OF_PLACE, 0);
6828 }
6829
6830 static int
6831 test_snow3g_auth_cipher_verify_test_case_1(void)
6832 {
6833         return test_snow3g_auth_cipher(
6834                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6835 }
6836
6837 static int
6838 test_snow3g_auth_cipher_verify_test_case_2(void)
6839 {
6840         return test_snow3g_auth_cipher(
6841                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6842 }
6843
6844 static int
6845 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6846 {
6847         return test_snow3g_auth_cipher(
6848                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6849 }
6850
6851 static int
6852 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6853 {
6854         return test_snow3g_auth_cipher(
6855                 &snow3g_auth_cipher_partial_digest_encryption,
6856                         IN_PLACE, 1);
6857 }
6858
6859 static int
6860 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6861 {
6862         return test_snow3g_auth_cipher(
6863                 &snow3g_auth_cipher_partial_digest_encryption,
6864                         OUT_OF_PLACE, 1);
6865 }
6866
6867 static int
6868 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6869 {
6870         return test_snow3g_auth_cipher_sgl(
6871                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6872 }
6873
6874 static int
6875 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6876 {
6877         return test_snow3g_auth_cipher_sgl(
6878                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6879 }
6880
6881 static int
6882 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6883 {
6884         return test_snow3g_auth_cipher_sgl(
6885                 &snow3g_auth_cipher_partial_digest_encryption,
6886                         IN_PLACE, 1);
6887 }
6888
6889 static int
6890 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6891 {
6892         return test_snow3g_auth_cipher_sgl(
6893                 &snow3g_auth_cipher_partial_digest_encryption,
6894                         OUT_OF_PLACE, 1);
6895 }
6896
6897 static int
6898 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6899 {
6900         return test_snow3g_auth_cipher(
6901                 &snow3g_test_case_7, IN_PLACE, 0);
6902 }
6903
6904 static int
6905 test_kasumi_auth_cipher_test_case_1(void)
6906 {
6907         return test_kasumi_auth_cipher(
6908                 &kasumi_test_case_3, IN_PLACE, 0);
6909 }
6910
6911 static int
6912 test_kasumi_auth_cipher_test_case_2(void)
6913 {
6914         return test_kasumi_auth_cipher(
6915                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6916 }
6917
6918 static int
6919 test_kasumi_auth_cipher_test_case_2_oop(void)
6920 {
6921         return test_kasumi_auth_cipher(
6922                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6923 }
6924
6925 static int
6926 test_kasumi_auth_cipher_test_case_2_sgl(void)
6927 {
6928         return test_kasumi_auth_cipher_sgl(
6929                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6930 }
6931
6932 static int
6933 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6934 {
6935         return test_kasumi_auth_cipher_sgl(
6936                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6937 }
6938
6939 static int
6940 test_kasumi_auth_cipher_verify_test_case_1(void)
6941 {
6942         return test_kasumi_auth_cipher(
6943                 &kasumi_test_case_3, IN_PLACE, 1);
6944 }
6945
6946 static int
6947 test_kasumi_auth_cipher_verify_test_case_2(void)
6948 {
6949         return test_kasumi_auth_cipher(
6950                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6951 }
6952
6953 static int
6954 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6955 {
6956         return test_kasumi_auth_cipher(
6957                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6958 }
6959
6960 static int
6961 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6962 {
6963         return test_kasumi_auth_cipher_sgl(
6964                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6965 }
6966
6967 static int
6968 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6969 {
6970         return test_kasumi_auth_cipher_sgl(
6971                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6972 }
6973
6974 static int
6975 test_kasumi_cipher_auth_test_case_1(void)
6976 {
6977         return test_kasumi_cipher_auth(&kasumi_test_case_6);
6978 }
6979
6980 static int
6981 test_zuc_encryption_test_case_1(void)
6982 {
6983         return test_zuc_encryption(&zuc_test_case_cipher_193b);
6984 }
6985
6986 static int
6987 test_zuc_encryption_test_case_2(void)
6988 {
6989         return test_zuc_encryption(&zuc_test_case_cipher_800b);
6990 }
6991
6992 static int
6993 test_zuc_encryption_test_case_3(void)
6994 {
6995         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6996 }
6997
6998 static int
6999 test_zuc_encryption_test_case_4(void)
7000 {
7001         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7002 }
7003
7004 static int
7005 test_zuc_encryption_test_case_5(void)
7006 {
7007         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7008 }
7009
7010 static int
7011 test_zuc_encryption_test_case_6_sgl(void)
7012 {
7013         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7014 }
7015
7016 static int
7017 test_zuc_encryption_test_case_7(void)
7018 {
7019         return test_zuc_encryption(&zuc_test_case_cipher_800b_key_256b);
7020 }
7021
7022 static int
7023 test_zuc_hash_generate_test_case_1(void)
7024 {
7025         return test_zuc_authentication(&zuc_test_case_auth_1b);
7026 }
7027
7028 static int
7029 test_zuc_hash_generate_test_case_2(void)
7030 {
7031         return test_zuc_authentication(&zuc_test_case_auth_90b);
7032 }
7033
7034 static int
7035 test_zuc_hash_generate_test_case_3(void)
7036 {
7037         return test_zuc_authentication(&zuc_test_case_auth_577b);
7038 }
7039
7040 static int
7041 test_zuc_hash_generate_test_case_4(void)
7042 {
7043         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7044 }
7045
7046 static int
7047 test_zuc_hash_generate_test_case_5(void)
7048 {
7049         return test_zuc_authentication(&zuc_test_auth_5670b);
7050 }
7051
7052 static int
7053 test_zuc_hash_generate_test_case_6(void)
7054 {
7055         return test_zuc_authentication(&zuc_test_case_auth_128b);
7056 }
7057
7058 static int
7059 test_zuc_hash_generate_test_case_7(void)
7060 {
7061         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7062 }
7063
7064 static int
7065 test_zuc_hash_generate_test_case_8(void)
7066 {
7067         return test_zuc_authentication(&zuc_test_case_auth_584b);
7068 }
7069
7070 static int
7071 test_zuc_hash_generate_test_case_9(void)
7072 {
7073         return test_zuc_authentication(&zuc_test_case_auth_584b_mac_64b);
7074 }
7075
7076 static int
7077 test_zuc_hash_generate_test_case_10(void)
7078 {
7079         return test_zuc_authentication(&zuc_test_case_auth_2080b_mac_128b);
7080 }
7081
7082 static int
7083 test_zuc_cipher_auth_test_case_1(void)
7084 {
7085         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7086 }
7087
7088 static int
7089 test_zuc_cipher_auth_test_case_2(void)
7090 {
7091         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7092 }
7093
7094 static int
7095 test_zuc_auth_cipher_test_case_1(void)
7096 {
7097         return test_zuc_auth_cipher(
7098                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7099 }
7100
7101 static int
7102 test_zuc_auth_cipher_test_case_1_oop(void)
7103 {
7104         return test_zuc_auth_cipher(
7105                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7106 }
7107
7108 static int
7109 test_zuc_auth_cipher_test_case_1_sgl(void)
7110 {
7111         return test_zuc_auth_cipher_sgl(
7112                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7113 }
7114
7115 static int
7116 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7117 {
7118         return test_zuc_auth_cipher_sgl(
7119                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7120 }
7121
7122 static int
7123 test_zuc_auth_cipher_verify_test_case_1(void)
7124 {
7125         return test_zuc_auth_cipher(
7126                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7127 }
7128
7129 static int
7130 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7131 {
7132         return test_zuc_auth_cipher(
7133                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7134 }
7135
7136 static int
7137 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7138 {
7139         return test_zuc_auth_cipher_sgl(
7140                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7141 }
7142
7143 static int
7144 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7145 {
7146         return test_zuc_auth_cipher_sgl(
7147                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7148 }
7149
7150 static int
7151 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7152 {
7153         uint8_t dev_id = testsuite_params.valid_devs[0];
7154
7155         struct rte_cryptodev_sym_capability_idx cap_idx;
7156
7157         /* Check if device supports particular cipher algorithm */
7158         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7159         cap_idx.algo.cipher = tdata->cipher_algo;
7160         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7161                 return TEST_SKIPPED;
7162
7163         /* Check if device supports particular hash algorithm */
7164         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7165         cap_idx.algo.auth = tdata->auth_algo;
7166         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7167                 return TEST_SKIPPED;
7168
7169         return 0;
7170 }
7171
7172 static int
7173 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7174         uint8_t op_mode, uint8_t verify)
7175 {
7176         struct crypto_testsuite_params *ts_params = &testsuite_params;
7177         struct crypto_unittest_params *ut_params = &unittest_params;
7178
7179         int retval;
7180
7181         uint8_t *plaintext = NULL, *ciphertext = NULL;
7182         unsigned int plaintext_pad_len;
7183         unsigned int plaintext_len;
7184         unsigned int ciphertext_pad_len;
7185         unsigned int ciphertext_len;
7186
7187         struct rte_cryptodev_info dev_info;
7188         struct rte_crypto_op *op;
7189
7190         /* Check if device supports particular algorithms separately */
7191         if (test_mixed_check_if_unsupported(tdata))
7192                 return TEST_SKIPPED;
7193         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7194                 return TEST_SKIPPED;
7195
7196         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7197
7198         uint64_t feat_flags = dev_info.feature_flags;
7199
7200         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7201                 printf("Device doesn't support digest encrypted.\n");
7202                 return TEST_SKIPPED;
7203         }
7204
7205         /* Create the session */
7206         if (verify)
7207                 retval = create_wireless_algo_cipher_auth_session(
7208                                 ts_params->valid_devs[0],
7209                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7210                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7211                                 tdata->auth_algo,
7212                                 tdata->cipher_algo,
7213                                 tdata->auth_key.data, tdata->auth_key.len,
7214                                 tdata->auth_iv.len, tdata->digest_enc.len,
7215                                 tdata->cipher_iv.len);
7216         else
7217                 retval = create_wireless_algo_auth_cipher_session(
7218                                 ts_params->valid_devs[0],
7219                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7220                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7221                                 tdata->auth_algo,
7222                                 tdata->cipher_algo,
7223                                 tdata->auth_key.data, tdata->auth_key.len,
7224                                 tdata->auth_iv.len, tdata->digest_enc.len,
7225                                 tdata->cipher_iv.len);
7226         if (retval != 0)
7227                 return retval;
7228
7229         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7230         if (op_mode == OUT_OF_PLACE)
7231                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7232
7233         /* clear mbuf payload */
7234         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7235                 rte_pktmbuf_tailroom(ut_params->ibuf));
7236         if (op_mode == OUT_OF_PLACE) {
7237
7238                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7239                                 rte_pktmbuf_tailroom(ut_params->obuf));
7240         }
7241
7242         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7243         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7244         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7245         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7246
7247         if (verify) {
7248                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7249                                 ciphertext_pad_len);
7250                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7251                 if (op_mode == OUT_OF_PLACE)
7252                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7253                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7254                                 ciphertext_len);
7255         } else {
7256                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7257                                 plaintext_pad_len);
7258                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7259                 if (op_mode == OUT_OF_PLACE)
7260                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
7261                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7262         }
7263
7264         /* Create the operation */
7265         retval = create_wireless_algo_auth_cipher_operation(
7266                         tdata->digest_enc.data, tdata->digest_enc.len,
7267                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7268                         tdata->auth_iv.data, tdata->auth_iv.len,
7269                         (tdata->digest_enc.offset == 0 ?
7270                                 plaintext_pad_len
7271                                 : tdata->digest_enc.offset),
7272                         tdata->validCipherLen.len_bits,
7273                         tdata->cipher.offset_bits,
7274                         tdata->validAuthLen.len_bits,
7275                         tdata->auth.offset_bits,
7276                         op_mode, 0, verify);
7277
7278         if (retval < 0)
7279                 return retval;
7280
7281         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7282
7283         /* Check if the op failed because the device doesn't */
7284         /* support this particular combination of algorithms */
7285         if (op == NULL && ut_params->op->status ==
7286                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7287                 printf("Device doesn't support this mixed combination. "
7288                                 "Test Skipped.\n");
7289                 return TEST_SKIPPED;
7290         }
7291         ut_params->op = op;
7292
7293         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7294
7295         ut_params->obuf = (op_mode == IN_PLACE ?
7296                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7297
7298         if (verify) {
7299                 if (ut_params->obuf)
7300                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7301                                                         uint8_t *);
7302                 else
7303                         plaintext = ciphertext +
7304                                         (tdata->cipher.offset_bits >> 3);
7305
7306                 debug_hexdump(stdout, "plaintext:", plaintext,
7307                                 tdata->plaintext.len_bits >> 3);
7308                 debug_hexdump(stdout, "plaintext expected:",
7309                                 tdata->plaintext.data,
7310                                 tdata->plaintext.len_bits >> 3);
7311         } else {
7312                 if (ut_params->obuf)
7313                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7314                                         uint8_t *);
7315                 else
7316                         ciphertext = plaintext;
7317
7318                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7319                                 ciphertext_len);
7320                 debug_hexdump(stdout, "ciphertext expected:",
7321                                 tdata->ciphertext.data,
7322                                 tdata->ciphertext.len_bits >> 3);
7323
7324                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7325                                 + (tdata->digest_enc.offset == 0 ?
7326                 plaintext_pad_len : tdata->digest_enc.offset);
7327
7328                 debug_hexdump(stdout, "digest:", ut_params->digest,
7329                                 tdata->digest_enc.len);
7330                 debug_hexdump(stdout, "digest expected:",
7331                                 tdata->digest_enc.data,
7332                                 tdata->digest_enc.len);
7333         }
7334
7335         /* Validate obuf */
7336         if (verify) {
7337                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7338                                 plaintext,
7339                                 tdata->plaintext.data,
7340                                 tdata->plaintext.len_bits >> 3,
7341                                 "Plaintext data not as expected");
7342         } else {
7343                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7344                                 ciphertext,
7345                                 tdata->ciphertext.data,
7346                                 tdata->validDataLen.len_bits,
7347                                 "Ciphertext data not as expected");
7348
7349                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7350                                 ut_params->digest,
7351                                 tdata->digest_enc.data,
7352                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
7353                                 "Generated auth tag not as expected");
7354         }
7355
7356         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7357                         "crypto op processing failed");
7358
7359         return 0;
7360 }
7361
7362 static int
7363 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7364         uint8_t op_mode, uint8_t verify)
7365 {
7366         struct crypto_testsuite_params *ts_params = &testsuite_params;
7367         struct crypto_unittest_params *ut_params = &unittest_params;
7368
7369         int retval;
7370
7371         const uint8_t *plaintext = NULL;
7372         const uint8_t *ciphertext = NULL;
7373         const uint8_t *digest = NULL;
7374         unsigned int plaintext_pad_len;
7375         unsigned int plaintext_len;
7376         unsigned int ciphertext_pad_len;
7377         unsigned int ciphertext_len;
7378         uint8_t buffer[10000];
7379         uint8_t digest_buffer[10000];
7380
7381         struct rte_cryptodev_info dev_info;
7382         struct rte_crypto_op *op;
7383
7384         /* Check if device supports particular algorithms */
7385         if (test_mixed_check_if_unsupported(tdata))
7386                 return TEST_SKIPPED;
7387         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7388                 return TEST_SKIPPED;
7389
7390         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7391
7392         uint64_t feat_flags = dev_info.feature_flags;
7393
7394         if (op_mode == IN_PLACE) {
7395                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7396                         printf("Device doesn't support in-place scatter-gather "
7397                                         "in both input and output mbufs.\n");
7398                         return TEST_SKIPPED;
7399                 }
7400         } else {
7401                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7402                         printf("Device doesn't support out-of-place scatter-gather "
7403                                         "in both input and output mbufs.\n");
7404                         return TEST_SKIPPED;
7405                 }
7406                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7407                         printf("Device doesn't support digest encrypted.\n");
7408                         return TEST_SKIPPED;
7409                 }
7410         }
7411
7412         /* Create the session */
7413         if (verify)
7414                 retval = create_wireless_algo_cipher_auth_session(
7415                                 ts_params->valid_devs[0],
7416                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7417                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7418                                 tdata->auth_algo,
7419                                 tdata->cipher_algo,
7420                                 tdata->auth_key.data, tdata->auth_key.len,
7421                                 tdata->auth_iv.len, tdata->digest_enc.len,
7422                                 tdata->cipher_iv.len);
7423         else
7424                 retval = create_wireless_algo_auth_cipher_session(
7425                                 ts_params->valid_devs[0],
7426                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7427                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7428                                 tdata->auth_algo,
7429                                 tdata->cipher_algo,
7430                                 tdata->auth_key.data, tdata->auth_key.len,
7431                                 tdata->auth_iv.len, tdata->digest_enc.len,
7432                                 tdata->cipher_iv.len);
7433         if (retval != 0)
7434                 return retval;
7435
7436         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7437         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7438         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7439         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7440
7441         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7442                         ciphertext_pad_len, 15, 0);
7443         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7444                         "Failed to allocate input buffer in mempool");
7445
7446         if (op_mode == OUT_OF_PLACE) {
7447                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7448                                 plaintext_pad_len, 15, 0);
7449                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7450                                 "Failed to allocate output buffer in mempool");
7451         }
7452
7453         if (verify) {
7454                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7455                         tdata->ciphertext.data);
7456                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7457                                         ciphertext_len, buffer);
7458                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7459                         ciphertext_len);
7460         } else {
7461                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7462                         tdata->plaintext.data);
7463                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7464                                         plaintext_len, buffer);
7465                 debug_hexdump(stdout, "plaintext:", plaintext,
7466                         plaintext_len);
7467         }
7468         memset(buffer, 0, sizeof(buffer));
7469
7470         /* Create the operation */
7471         retval = create_wireless_algo_auth_cipher_operation(
7472                         tdata->digest_enc.data, tdata->digest_enc.len,
7473                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7474                         tdata->auth_iv.data, tdata->auth_iv.len,
7475                         (tdata->digest_enc.offset == 0 ?
7476                                 plaintext_pad_len
7477                                 : tdata->digest_enc.offset),
7478                         tdata->validCipherLen.len_bits,
7479                         tdata->cipher.offset_bits,
7480                         tdata->validAuthLen.len_bits,
7481                         tdata->auth.offset_bits,
7482                         op_mode, 1, verify);
7483
7484         if (retval < 0)
7485                 return retval;
7486
7487         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7488
7489         /* Check if the op failed because the device doesn't */
7490         /* support this particular combination of algorithms */
7491         if (op == NULL && ut_params->op->status ==
7492                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7493                 printf("Device doesn't support this mixed combination. "
7494                                 "Test Skipped.\n");
7495                 return TEST_SKIPPED;
7496         }
7497         ut_params->op = op;
7498
7499         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7500
7501         ut_params->obuf = (op_mode == IN_PLACE ?
7502                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7503
7504         if (verify) {
7505                 if (ut_params->obuf)
7506                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7507                                         plaintext_len, buffer);
7508                 else
7509                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7510                                         plaintext_len, buffer);
7511
7512                 debug_hexdump(stdout, "plaintext:", plaintext,
7513                                 (tdata->plaintext.len_bits >> 3) -
7514                                 tdata->digest_enc.len);
7515                 debug_hexdump(stdout, "plaintext expected:",
7516                                 tdata->plaintext.data,
7517                                 (tdata->plaintext.len_bits >> 3) -
7518                                 tdata->digest_enc.len);
7519         } else {
7520                 if (ut_params->obuf)
7521                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7522                                         ciphertext_len, buffer);
7523                 else
7524                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7525                                         ciphertext_len, buffer);
7526
7527                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7528                         ciphertext_len);
7529                 debug_hexdump(stdout, "ciphertext expected:",
7530                         tdata->ciphertext.data,
7531                         tdata->ciphertext.len_bits >> 3);
7532
7533                 if (ut_params->obuf)
7534                         digest = rte_pktmbuf_read(ut_params->obuf,
7535                                         (tdata->digest_enc.offset == 0 ?
7536                                                 plaintext_pad_len :
7537                                                 tdata->digest_enc.offset),
7538                                         tdata->digest_enc.len, digest_buffer);
7539                 else
7540                         digest = rte_pktmbuf_read(ut_params->ibuf,
7541                                         (tdata->digest_enc.offset == 0 ?
7542                                                 plaintext_pad_len :
7543                                                 tdata->digest_enc.offset),
7544                                         tdata->digest_enc.len, digest_buffer);
7545
7546                 debug_hexdump(stdout, "digest:", digest,
7547                                 tdata->digest_enc.len);
7548                 debug_hexdump(stdout, "digest expected:",
7549                                 tdata->digest_enc.data, tdata->digest_enc.len);
7550         }
7551
7552         /* Validate obuf */
7553         if (verify) {
7554                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7555                                 plaintext,
7556                                 tdata->plaintext.data,
7557                                 tdata->plaintext.len_bits >> 3,
7558                                 "Plaintext data not as expected");
7559         } else {
7560                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7561                                 ciphertext,
7562                                 tdata->ciphertext.data,
7563                                 tdata->validDataLen.len_bits,
7564                                 "Ciphertext data not as expected");
7565                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7566                                 digest,
7567                                 tdata->digest_enc.data,
7568                                 tdata->digest_enc.len,
7569                                 "Generated auth tag not as expected");
7570         }
7571
7572         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7573                         "crypto op processing failed");
7574
7575         return 0;
7576 }
7577
7578 /** AUTH AES CMAC + CIPHER AES CTR */
7579
7580 static int
7581 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7582 {
7583         return test_mixed_auth_cipher(
7584                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7585 }
7586
7587 static int
7588 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7589 {
7590         return test_mixed_auth_cipher(
7591                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7592 }
7593
7594 static int
7595 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7596 {
7597         return test_mixed_auth_cipher_sgl(
7598                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7599 }
7600
7601 static int
7602 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7603 {
7604         return test_mixed_auth_cipher_sgl(
7605                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7606 }
7607
7608 static int
7609 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7610 {
7611         return test_mixed_auth_cipher(
7612                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7613 }
7614
7615 static int
7616 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7617 {
7618         return test_mixed_auth_cipher(
7619                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7620 }
7621
7622 static int
7623 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7624 {
7625         return test_mixed_auth_cipher_sgl(
7626                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7627 }
7628
7629 static int
7630 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7631 {
7632         return test_mixed_auth_cipher_sgl(
7633                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7634 }
7635
7636 /** MIXED AUTH + CIPHER */
7637
7638 static int
7639 test_auth_zuc_cipher_snow_test_case_1(void)
7640 {
7641         return test_mixed_auth_cipher(
7642                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7643 }
7644
7645 static int
7646 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7647 {
7648         return test_mixed_auth_cipher(
7649                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7650 }
7651
7652 static int
7653 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7654 {
7655         return test_mixed_auth_cipher(
7656                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7657 }
7658
7659 static int
7660 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7661 {
7662         return test_mixed_auth_cipher(
7663                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7664 }
7665
7666 static int
7667 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7668 {
7669         return test_mixed_auth_cipher(
7670                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7671 }
7672
7673 static int
7674 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7675 {
7676         return test_mixed_auth_cipher(
7677                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7678 }
7679
7680 static int
7681 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7682 {
7683         return test_mixed_auth_cipher(
7684                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7685 }
7686
7687 static int
7688 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7689 {
7690         return test_mixed_auth_cipher(
7691                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7692 }
7693
7694 static int
7695 test_auth_snow_cipher_zuc_test_case_1(void)
7696 {
7697         return test_mixed_auth_cipher(
7698                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7699 }
7700
7701 static int
7702 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7703 {
7704         return test_mixed_auth_cipher(
7705                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7706 }
7707
7708 static int
7709 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7710 {
7711         return test_mixed_auth_cipher(
7712                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7713 }
7714
7715 static int
7716 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7717 {
7718         return test_mixed_auth_cipher(
7719                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7720 }
7721
7722 static int
7723 test_auth_null_cipher_snow_test_case_1(void)
7724 {
7725         return test_mixed_auth_cipher(
7726                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7727 }
7728
7729 static int
7730 test_verify_auth_null_cipher_snow_test_case_1(void)
7731 {
7732         return test_mixed_auth_cipher(
7733                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7734 }
7735
7736 static int
7737 test_auth_null_cipher_zuc_test_case_1(void)
7738 {
7739         return test_mixed_auth_cipher(
7740                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7741 }
7742
7743 static int
7744 test_verify_auth_null_cipher_zuc_test_case_1(void)
7745 {
7746         return test_mixed_auth_cipher(
7747                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7748 }
7749
7750 static int
7751 test_auth_snow_cipher_null_test_case_1(void)
7752 {
7753         return test_mixed_auth_cipher(
7754                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7755 }
7756
7757 static int
7758 test_verify_auth_snow_cipher_null_test_case_1(void)
7759 {
7760         return test_mixed_auth_cipher(
7761                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7762 }
7763
7764 static int
7765 test_auth_zuc_cipher_null_test_case_1(void)
7766 {
7767         return test_mixed_auth_cipher(
7768                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7769 }
7770
7771 static int
7772 test_verify_auth_zuc_cipher_null_test_case_1(void)
7773 {
7774         return test_mixed_auth_cipher(
7775                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7776 }
7777
7778 static int
7779 test_auth_null_cipher_aes_ctr_test_case_1(void)
7780 {
7781         return test_mixed_auth_cipher(
7782                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7783 }
7784
7785 static int
7786 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7787 {
7788         return test_mixed_auth_cipher(
7789                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7790 }
7791
7792 static int
7793 test_auth_aes_cmac_cipher_null_test_case_1(void)
7794 {
7795         return test_mixed_auth_cipher(
7796                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7797 }
7798
7799 static int
7800 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7801 {
7802         return test_mixed_auth_cipher(
7803                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7804 }
7805
7806 /* ***** AEAD algorithm Tests ***** */
7807
7808 static int
7809 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7810                 enum rte_crypto_aead_operation op,
7811                 const uint8_t *key, const uint8_t key_len,
7812                 const uint16_t aad_len, const uint8_t auth_len,
7813                 uint8_t iv_len)
7814 {
7815         uint8_t aead_key[key_len];
7816
7817         struct crypto_testsuite_params *ts_params = &testsuite_params;
7818         struct crypto_unittest_params *ut_params = &unittest_params;
7819
7820         memcpy(aead_key, key, key_len);
7821
7822         /* Setup AEAD Parameters */
7823         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7824         ut_params->aead_xform.next = NULL;
7825         ut_params->aead_xform.aead.algo = algo;
7826         ut_params->aead_xform.aead.op = op;
7827         ut_params->aead_xform.aead.key.data = aead_key;
7828         ut_params->aead_xform.aead.key.length = key_len;
7829         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7830         ut_params->aead_xform.aead.iv.length = iv_len;
7831         ut_params->aead_xform.aead.digest_length = auth_len;
7832         ut_params->aead_xform.aead.aad_length = aad_len;
7833
7834         debug_hexdump(stdout, "key:", key, key_len);
7835
7836         /* Create Crypto session*/
7837         ut_params->sess = rte_cryptodev_sym_session_create(
7838                         ts_params->session_mpool);
7839
7840         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7841                         &ut_params->aead_xform,
7842                         ts_params->session_priv_mpool);
7843
7844         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7845
7846         return 0;
7847 }
7848
7849 static int
7850 create_aead_xform(struct rte_crypto_op *op,
7851                 enum rte_crypto_aead_algorithm algo,
7852                 enum rte_crypto_aead_operation aead_op,
7853                 uint8_t *key, const uint8_t key_len,
7854                 const uint8_t aad_len, const uint8_t auth_len,
7855                 uint8_t iv_len)
7856 {
7857         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7858                         "failed to allocate space for crypto transform");
7859
7860         struct rte_crypto_sym_op *sym_op = op->sym;
7861
7862         /* Setup AEAD Parameters */
7863         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7864         sym_op->xform->next = NULL;
7865         sym_op->xform->aead.algo = algo;
7866         sym_op->xform->aead.op = aead_op;
7867         sym_op->xform->aead.key.data = key;
7868         sym_op->xform->aead.key.length = key_len;
7869         sym_op->xform->aead.iv.offset = IV_OFFSET;
7870         sym_op->xform->aead.iv.length = iv_len;
7871         sym_op->xform->aead.digest_length = auth_len;
7872         sym_op->xform->aead.aad_length = aad_len;
7873
7874         debug_hexdump(stdout, "key:", key, key_len);
7875
7876         return 0;
7877 }
7878
7879 static int
7880 create_aead_operation(enum rte_crypto_aead_operation op,
7881                 const struct aead_test_data *tdata)
7882 {
7883         struct crypto_testsuite_params *ts_params = &testsuite_params;
7884         struct crypto_unittest_params *ut_params = &unittest_params;
7885
7886         uint8_t *plaintext, *ciphertext;
7887         unsigned int aad_pad_len, plaintext_pad_len;
7888
7889         /* Generate Crypto op data structure */
7890         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7891                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7892         TEST_ASSERT_NOT_NULL(ut_params->op,
7893                         "Failed to allocate symmetric crypto operation struct");
7894
7895         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7896
7897         /* Append aad data */
7898         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7899                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7900                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7901                                 aad_pad_len);
7902                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7903                                 "no room to append aad");
7904
7905                 sym_op->aead.aad.phys_addr =
7906                                 rte_pktmbuf_iova(ut_params->ibuf);
7907                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7908                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7909                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7910                         tdata->aad.len);
7911
7912                 /* Append IV at the end of the crypto operation*/
7913                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7914                                 uint8_t *, IV_OFFSET);
7915
7916                 /* Copy IV 1 byte after the IV pointer, according to the API */
7917                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7918                 debug_hexdump(stdout, "iv:", iv_ptr,
7919                         tdata->iv.len);
7920         } else {
7921                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7922                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7923                                 aad_pad_len);
7924                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7925                                 "no room to append aad");
7926
7927                 sym_op->aead.aad.phys_addr =
7928                                 rte_pktmbuf_iova(ut_params->ibuf);
7929                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7930                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7931                         tdata->aad.len);
7932
7933                 /* Append IV at the end of the crypto operation*/
7934                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7935                                 uint8_t *, IV_OFFSET);
7936
7937                 if (tdata->iv.len == 0) {
7938                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7939                         debug_hexdump(stdout, "iv:", iv_ptr,
7940                                 AES_GCM_J0_LENGTH);
7941                 } else {
7942                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7943                         debug_hexdump(stdout, "iv:", iv_ptr,
7944                                 tdata->iv.len);
7945                 }
7946         }
7947
7948         /* Append plaintext/ciphertext */
7949         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7950                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7951                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7952                                 plaintext_pad_len);
7953                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7954
7955                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7956                 debug_hexdump(stdout, "plaintext:", plaintext,
7957                                 tdata->plaintext.len);
7958
7959                 if (ut_params->obuf) {
7960                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7961                                         ut_params->obuf,
7962                                         plaintext_pad_len + aad_pad_len);
7963                         TEST_ASSERT_NOT_NULL(ciphertext,
7964                                         "no room to append ciphertext");
7965
7966                         memset(ciphertext + aad_pad_len, 0,
7967                                         tdata->ciphertext.len);
7968                 }
7969         } else {
7970                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7971                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7972                                 plaintext_pad_len);
7973                 TEST_ASSERT_NOT_NULL(ciphertext,
7974                                 "no room to append ciphertext");
7975
7976                 memcpy(ciphertext, tdata->ciphertext.data,
7977                                 tdata->ciphertext.len);
7978                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7979                                 tdata->ciphertext.len);
7980
7981                 if (ut_params->obuf) {
7982                         plaintext = (uint8_t *)rte_pktmbuf_append(
7983                                         ut_params->obuf,
7984                                         plaintext_pad_len + aad_pad_len);
7985                         TEST_ASSERT_NOT_NULL(plaintext,
7986                                         "no room to append plaintext");
7987
7988                         memset(plaintext + aad_pad_len, 0,
7989                                         tdata->plaintext.len);
7990                 }
7991         }
7992
7993         /* Append digest data */
7994         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7995                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7996                                 ut_params->obuf ? ut_params->obuf :
7997                                                 ut_params->ibuf,
7998                                                 tdata->auth_tag.len);
7999                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8000                                 "no room to append digest");
8001                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8002                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8003                                 ut_params->obuf ? ut_params->obuf :
8004                                                 ut_params->ibuf,
8005                                                 plaintext_pad_len +
8006                                                 aad_pad_len);
8007         } else {
8008                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8009                                 ut_params->ibuf, tdata->auth_tag.len);
8010                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8011                                 "no room to append digest");
8012                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8013                                 ut_params->ibuf,
8014                                 plaintext_pad_len + aad_pad_len);
8015
8016                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8017                         tdata->auth_tag.len);
8018                 debug_hexdump(stdout, "digest:",
8019                         sym_op->aead.digest.data,
8020                         tdata->auth_tag.len);
8021         }
8022
8023         sym_op->aead.data.length = tdata->plaintext.len;
8024         sym_op->aead.data.offset = aad_pad_len;
8025
8026         return 0;
8027 }
8028
8029 static int
8030 test_authenticated_encryption(const struct aead_test_data *tdata)
8031 {
8032         struct crypto_testsuite_params *ts_params = &testsuite_params;
8033         struct crypto_unittest_params *ut_params = &unittest_params;
8034
8035         int retval;
8036         uint8_t *ciphertext, *auth_tag;
8037         uint16_t plaintext_pad_len;
8038         uint32_t i;
8039         struct rte_cryptodev_info dev_info;
8040
8041         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8042         uint64_t feat_flags = dev_info.feature_flags;
8043
8044         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8045                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8046                 printf("Device doesn't support RAW data-path APIs.\n");
8047                 return TEST_SKIPPED;
8048         }
8049
8050         /* Verify the capabilities */
8051         struct rte_cryptodev_sym_capability_idx cap_idx;
8052         const struct rte_cryptodev_symmetric_capability *capability;
8053         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8054         cap_idx.algo.aead = tdata->algo;
8055         capability = rte_cryptodev_sym_capability_get(
8056                         ts_params->valid_devs[0], &cap_idx);
8057         if (capability == NULL)
8058                 return TEST_SKIPPED;
8059         if (rte_cryptodev_sym_capability_check_aead(
8060                         capability, tdata->key.len, tdata->auth_tag.len,
8061                         tdata->aad.len, tdata->iv.len))
8062                 return TEST_SKIPPED;
8063
8064         /* Create AEAD session */
8065         retval = create_aead_session(ts_params->valid_devs[0],
8066                         tdata->algo,
8067                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8068                         tdata->key.data, tdata->key.len,
8069                         tdata->aad.len, tdata->auth_tag.len,
8070                         tdata->iv.len);
8071         if (retval < 0)
8072                 return retval;
8073
8074         if (tdata->aad.len > MBUF_SIZE) {
8075                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8076                 /* Populate full size of add data */
8077                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8078                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8079         } else
8080                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8081
8082         /* clear mbuf payload */
8083         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8084                         rte_pktmbuf_tailroom(ut_params->ibuf));
8085
8086         /* Create AEAD operation */
8087         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8088         if (retval < 0)
8089                 return retval;
8090
8091         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8092
8093         ut_params->op->sym->m_src = ut_params->ibuf;
8094
8095         /* Process crypto operation */
8096         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8097                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8098         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8099                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8100                                 ut_params->op, 0, 0, 0, 0);
8101         else
8102                 TEST_ASSERT_NOT_NULL(
8103                         process_crypto_request(ts_params->valid_devs[0],
8104                         ut_params->op), "failed to process sym crypto op");
8105
8106         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8107                         "crypto op processing failed");
8108
8109         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8110
8111         if (ut_params->op->sym->m_dst) {
8112                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8113                                 uint8_t *);
8114                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8115                                 uint8_t *, plaintext_pad_len);
8116         } else {
8117                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8118                                 uint8_t *,
8119                                 ut_params->op->sym->cipher.data.offset);
8120                 auth_tag = ciphertext + plaintext_pad_len;
8121         }
8122
8123         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8124         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8125
8126         /* Validate obuf */
8127         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8128                         ciphertext,
8129                         tdata->ciphertext.data,
8130                         tdata->ciphertext.len,
8131                         "Ciphertext data not as expected");
8132
8133         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8134                         auth_tag,
8135                         tdata->auth_tag.data,
8136                         tdata->auth_tag.len,
8137                         "Generated auth tag not as expected");
8138
8139         return 0;
8140
8141 }
8142
8143 #ifdef RTE_LIB_SECURITY
8144 static int
8145 security_proto_supported(enum rte_security_session_action_type action,
8146         enum rte_security_session_protocol proto)
8147 {
8148         struct crypto_testsuite_params *ts_params = &testsuite_params;
8149
8150         const struct rte_security_capability *capabilities;
8151         const struct rte_security_capability *capability;
8152         uint16_t i = 0;
8153
8154         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8155                                 rte_cryptodev_get_sec_ctx(
8156                                 ts_params->valid_devs[0]);
8157
8158
8159         capabilities = rte_security_capabilities_get(ctx);
8160
8161         if (capabilities == NULL)
8162                 return -ENOTSUP;
8163
8164         while ((capability = &capabilities[i++])->action !=
8165                         RTE_SECURITY_ACTION_TYPE_NONE) {
8166                 if (capability->action == action &&
8167                                 capability->protocol == proto)
8168                         return 0;
8169         }
8170
8171         return -ENOTSUP;
8172 }
8173
8174 /* Basic algorithm run function for async inplace mode.
8175  * Creates a session from input parameters and runs one operation
8176  * on input_vec. Checks the output of the crypto operation against
8177  * output_vec.
8178  */
8179 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8180                            enum rte_crypto_auth_operation opa,
8181                            const uint8_t *input_vec, unsigned int input_vec_len,
8182                            const uint8_t *output_vec,
8183                            unsigned int output_vec_len,
8184                            enum rte_crypto_cipher_algorithm cipher_alg,
8185                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8186                            enum rte_crypto_auth_algorithm auth_alg,
8187                            const uint8_t *auth_key, uint32_t auth_key_len,
8188                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8189                            uint8_t packet_direction, uint8_t sn_size,
8190                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8191 {
8192         struct crypto_testsuite_params *ts_params = &testsuite_params;
8193         struct crypto_unittest_params *ut_params = &unittest_params;
8194         uint8_t *plaintext;
8195         int ret = TEST_SUCCESS;
8196         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8197                                 rte_cryptodev_get_sec_ctx(
8198                                 ts_params->valid_devs[0]);
8199
8200         /* Verify the capabilities */
8201         struct rte_security_capability_idx sec_cap_idx;
8202
8203         sec_cap_idx.action = ut_params->type;
8204         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8205         sec_cap_idx.pdcp.domain = domain;
8206         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8207                 return TEST_SKIPPED;
8208
8209         /* Generate test mbuf data */
8210         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8211
8212         /* clear mbuf payload */
8213         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8214                         rte_pktmbuf_tailroom(ut_params->ibuf));
8215
8216         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8217                                                   input_vec_len);
8218         memcpy(plaintext, input_vec, input_vec_len);
8219
8220         /* Out of place support */
8221         if (oop) {
8222                 /*
8223                  * For out-op-place we need to alloc another mbuf
8224                  */
8225                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8226                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8227         }
8228
8229         /* Setup Cipher Parameters */
8230         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8231         ut_params->cipher_xform.cipher.algo = cipher_alg;
8232         ut_params->cipher_xform.cipher.op = opc;
8233         ut_params->cipher_xform.cipher.key.data = cipher_key;
8234         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8235         ut_params->cipher_xform.cipher.iv.length =
8236                                 packet_direction ? 4 : 0;
8237         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8238
8239         /* Setup HMAC Parameters if ICV header is required */
8240         if (auth_alg != 0) {
8241                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8242                 ut_params->auth_xform.next = NULL;
8243                 ut_params->auth_xform.auth.algo = auth_alg;
8244                 ut_params->auth_xform.auth.op = opa;
8245                 ut_params->auth_xform.auth.key.data = auth_key;
8246                 ut_params->auth_xform.auth.key.length = auth_key_len;
8247
8248                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8249         } else {
8250                 ut_params->cipher_xform.next = NULL;
8251         }
8252
8253         struct rte_security_session_conf sess_conf = {
8254                 .action_type = ut_params->type,
8255                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8256                 {.pdcp = {
8257                         .bearer = bearer,
8258                         .domain = domain,
8259                         .pkt_dir = packet_direction,
8260                         .sn_size = sn_size,
8261                         .hfn = packet_direction ? 0 : hfn,
8262                         /**
8263                          * hfn can be set as pdcp_test_hfn[i]
8264                          * if hfn_ovrd is not set. Here, PDCP
8265                          * packet direction is just used to
8266                          * run half of the cases with session
8267                          * HFN and other half with per packet
8268                          * HFN.
8269                          */
8270                         .hfn_threshold = hfn_threshold,
8271                         .hfn_ovrd = packet_direction ? 1 : 0,
8272                         .sdap_enabled = sdap,
8273                 } },
8274                 .crypto_xform = &ut_params->cipher_xform
8275         };
8276
8277         /* Create security session */
8278         ut_params->sec_session = rte_security_session_create(ctx,
8279                                 &sess_conf, ts_params->session_mpool,
8280                                 ts_params->session_priv_mpool);
8281
8282         if (!ut_params->sec_session) {
8283                 printf("TestCase %s()-%d line %d failed %s: ",
8284                         __func__, i, __LINE__, "Failed to allocate session");
8285                 ret = TEST_FAILED;
8286                 goto on_err;
8287         }
8288
8289         /* Generate crypto op data structure */
8290         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8291                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8292         if (!ut_params->op) {
8293                 printf("TestCase %s()-%d line %d failed %s: ",
8294                         __func__, i, __LINE__,
8295                         "Failed to allocate symmetric crypto operation struct");
8296                 ret = TEST_FAILED;
8297                 goto on_err;
8298         }
8299
8300         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8301                                         uint32_t *, IV_OFFSET);
8302         *per_pkt_hfn = packet_direction ? hfn : 0;
8303
8304         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8305
8306         /* set crypto operation source mbuf */
8307         ut_params->op->sym->m_src = ut_params->ibuf;
8308         if (oop)
8309                 ut_params->op->sym->m_dst = ut_params->obuf;
8310
8311         /* Process crypto operation */
8312         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8313                 == NULL) {
8314                 printf("TestCase %s()-%d line %d failed %s: ",
8315                         __func__, i, __LINE__,
8316                         "failed to process sym crypto op");
8317                 ret = TEST_FAILED;
8318                 goto on_err;
8319         }
8320
8321         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8322                 printf("TestCase %s()-%d line %d failed %s: ",
8323                         __func__, i, __LINE__, "crypto op processing failed");
8324                 ret = TEST_FAILED;
8325                 goto on_err;
8326         }
8327
8328         /* Validate obuf */
8329         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8330                         uint8_t *);
8331         if (oop) {
8332                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8333                                 uint8_t *);
8334         }
8335
8336         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8337                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8338                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8339                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8340                 ret = TEST_FAILED;
8341                 goto on_err;
8342         }
8343
8344 on_err:
8345         rte_crypto_op_free(ut_params->op);
8346         ut_params->op = NULL;
8347
8348         if (ut_params->sec_session)
8349                 rte_security_session_destroy(ctx, ut_params->sec_session);
8350         ut_params->sec_session = NULL;
8351
8352         rte_pktmbuf_free(ut_params->ibuf);
8353         ut_params->ibuf = NULL;
8354         if (oop) {
8355                 rte_pktmbuf_free(ut_params->obuf);
8356                 ut_params->obuf = NULL;
8357         }
8358
8359         return ret;
8360 }
8361
8362 static int
8363 test_pdcp_proto_SGL(int i, int oop,
8364         enum rte_crypto_cipher_operation opc,
8365         enum rte_crypto_auth_operation opa,
8366         uint8_t *input_vec,
8367         unsigned int input_vec_len,
8368         uint8_t *output_vec,
8369         unsigned int output_vec_len,
8370         uint32_t fragsz,
8371         uint32_t fragsz_oop)
8372 {
8373         struct crypto_testsuite_params *ts_params = &testsuite_params;
8374         struct crypto_unittest_params *ut_params = &unittest_params;
8375         uint8_t *plaintext;
8376         struct rte_mbuf *buf, *buf_oop = NULL;
8377         int ret = TEST_SUCCESS;
8378         int to_trn = 0;
8379         int to_trn_tbl[16];
8380         int segs = 1;
8381         unsigned int trn_data = 0;
8382         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8383                                 rte_cryptodev_get_sec_ctx(
8384                                 ts_params->valid_devs[0]);
8385
8386         /* Verify the capabilities */
8387         struct rte_security_capability_idx sec_cap_idx;
8388
8389         sec_cap_idx.action = ut_params->type;
8390         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8391         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8392         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8393                 return TEST_SKIPPED;
8394
8395         if (fragsz > input_vec_len)
8396                 fragsz = input_vec_len;
8397
8398         uint16_t plaintext_len = fragsz;
8399         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8400
8401         if (fragsz_oop > output_vec_len)
8402                 frag_size_oop = output_vec_len;
8403
8404         int ecx = 0;
8405         if (input_vec_len % fragsz != 0) {
8406                 if (input_vec_len / fragsz + 1 > 16)
8407                         return 1;
8408         } else if (input_vec_len / fragsz > 16)
8409                 return 1;
8410
8411         /* Out of place support */
8412         if (oop) {
8413                 /*
8414                  * For out-op-place we need to alloc another mbuf
8415                  */
8416                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8417                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8418                 buf_oop = ut_params->obuf;
8419         }
8420
8421         /* Generate test mbuf data */
8422         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8423
8424         /* clear mbuf payload */
8425         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8426                         rte_pktmbuf_tailroom(ut_params->ibuf));
8427
8428         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8429                                                   plaintext_len);
8430         memcpy(plaintext, input_vec, plaintext_len);
8431         trn_data += plaintext_len;
8432
8433         buf = ut_params->ibuf;
8434
8435         /*
8436          * Loop until no more fragments
8437          */
8438
8439         while (trn_data < input_vec_len) {
8440                 ++segs;
8441                 to_trn = (input_vec_len - trn_data < fragsz) ?
8442                                 (input_vec_len - trn_data) : fragsz;
8443
8444                 to_trn_tbl[ecx++] = to_trn;
8445
8446                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8447                 buf = buf->next;
8448
8449                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8450                                 rte_pktmbuf_tailroom(buf));
8451
8452                 /* OOP */
8453                 if (oop && !fragsz_oop) {
8454                         buf_oop->next =
8455                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8456                         buf_oop = buf_oop->next;
8457                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8458                                         0, rte_pktmbuf_tailroom(buf_oop));
8459                         rte_pktmbuf_append(buf_oop, to_trn);
8460                 }
8461
8462                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8463                                 to_trn);
8464
8465                 memcpy(plaintext, input_vec + trn_data, to_trn);
8466                 trn_data += to_trn;
8467         }
8468
8469         ut_params->ibuf->nb_segs = segs;
8470
8471         segs = 1;
8472         if (fragsz_oop && oop) {
8473                 to_trn = 0;
8474                 ecx = 0;
8475
8476                 trn_data = frag_size_oop;
8477                 while (trn_data < output_vec_len) {
8478                         ++segs;
8479                         to_trn =
8480                                 (output_vec_len - trn_data <
8481                                                 frag_size_oop) ?
8482                                 (output_vec_len - trn_data) :
8483                                                 frag_size_oop;
8484
8485                         to_trn_tbl[ecx++] = to_trn;
8486
8487                         buf_oop->next =
8488                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8489                         buf_oop = buf_oop->next;
8490                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8491                                         0, rte_pktmbuf_tailroom(buf_oop));
8492                         rte_pktmbuf_append(buf_oop, to_trn);
8493
8494                         trn_data += to_trn;
8495                 }
8496                 ut_params->obuf->nb_segs = segs;
8497         }
8498
8499         /* Setup Cipher Parameters */
8500         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8501         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8502         ut_params->cipher_xform.cipher.op = opc;
8503         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8504         ut_params->cipher_xform.cipher.key.length =
8505                                         pdcp_test_params[i].cipher_key_len;
8506         ut_params->cipher_xform.cipher.iv.length = 0;
8507
8508         /* Setup HMAC Parameters if ICV header is required */
8509         if (pdcp_test_params[i].auth_alg != 0) {
8510                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8511                 ut_params->auth_xform.next = NULL;
8512                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8513                 ut_params->auth_xform.auth.op = opa;
8514                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8515                 ut_params->auth_xform.auth.key.length =
8516                                         pdcp_test_params[i].auth_key_len;
8517
8518                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8519         } else {
8520                 ut_params->cipher_xform.next = NULL;
8521         }
8522
8523         struct rte_security_session_conf sess_conf = {
8524                 .action_type = ut_params->type,
8525                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8526                 {.pdcp = {
8527                         .bearer = pdcp_test_bearer[i],
8528                         .domain = pdcp_test_params[i].domain,
8529                         .pkt_dir = pdcp_test_packet_direction[i],
8530                         .sn_size = pdcp_test_data_sn_size[i],
8531                         .hfn = pdcp_test_hfn[i],
8532                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8533                         .hfn_ovrd = 0,
8534                 } },
8535                 .crypto_xform = &ut_params->cipher_xform
8536         };
8537
8538         /* Create security session */
8539         ut_params->sec_session = rte_security_session_create(ctx,
8540                                 &sess_conf, ts_params->session_mpool,
8541                                 ts_params->session_priv_mpool);
8542
8543         if (!ut_params->sec_session) {
8544                 printf("TestCase %s()-%d line %d failed %s: ",
8545                         __func__, i, __LINE__, "Failed to allocate session");
8546                 ret = TEST_FAILED;
8547                 goto on_err;
8548         }
8549
8550         /* Generate crypto op data structure */
8551         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8552                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8553         if (!ut_params->op) {
8554                 printf("TestCase %s()-%d line %d failed %s: ",
8555                         __func__, i, __LINE__,
8556                         "Failed to allocate symmetric crypto operation struct");
8557                 ret = TEST_FAILED;
8558                 goto on_err;
8559         }
8560
8561         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8562
8563         /* set crypto operation source mbuf */
8564         ut_params->op->sym->m_src = ut_params->ibuf;
8565         if (oop)
8566                 ut_params->op->sym->m_dst = ut_params->obuf;
8567
8568         /* Process crypto operation */
8569         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8570                 == NULL) {
8571                 printf("TestCase %s()-%d line %d failed %s: ",
8572                         __func__, i, __LINE__,
8573                         "failed to process sym crypto op");
8574                 ret = TEST_FAILED;
8575                 goto on_err;
8576         }
8577
8578         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8579                 printf("TestCase %s()-%d line %d failed %s: ",
8580                         __func__, i, __LINE__, "crypto op processing failed");
8581                 ret = TEST_FAILED;
8582                 goto on_err;
8583         }
8584
8585         /* Validate obuf */
8586         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8587                         uint8_t *);
8588         if (oop) {
8589                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8590                                 uint8_t *);
8591         }
8592         if (fragsz_oop)
8593                 fragsz = frag_size_oop;
8594         if (memcmp(ciphertext, output_vec, fragsz)) {
8595                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8596                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8597                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8598                 ret = TEST_FAILED;
8599                 goto on_err;
8600         }
8601
8602         buf = ut_params->op->sym->m_src->next;
8603         if (oop)
8604                 buf = ut_params->op->sym->m_dst->next;
8605
8606         unsigned int off = fragsz;
8607
8608         ecx = 0;
8609         while (buf) {
8610                 ciphertext = rte_pktmbuf_mtod(buf,
8611                                 uint8_t *);
8612                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8613                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8614                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8615                         rte_hexdump(stdout, "reference", output_vec + off,
8616                                         to_trn_tbl[ecx]);
8617                         ret = TEST_FAILED;
8618                         goto on_err;
8619                 }
8620                 off += to_trn_tbl[ecx++];
8621                 buf = buf->next;
8622         }
8623 on_err:
8624         rte_crypto_op_free(ut_params->op);
8625         ut_params->op = NULL;
8626
8627         if (ut_params->sec_session)
8628                 rte_security_session_destroy(ctx, ut_params->sec_session);
8629         ut_params->sec_session = NULL;
8630
8631         rte_pktmbuf_free(ut_params->ibuf);
8632         ut_params->ibuf = NULL;
8633         if (oop) {
8634                 rte_pktmbuf_free(ut_params->obuf);
8635                 ut_params->obuf = NULL;
8636         }
8637
8638         return ret;
8639 }
8640
8641 int
8642 test_pdcp_proto_cplane_encap(int i)
8643 {
8644         return test_pdcp_proto(
8645                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8646                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8647                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8648                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8649                 pdcp_test_params[i].cipher_key_len,
8650                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8651                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8652                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8653                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8654                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8655 }
8656
8657 int
8658 test_pdcp_proto_uplane_encap(int i)
8659 {
8660         return test_pdcp_proto(
8661                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8662                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8663                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8664                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8665                 pdcp_test_params[i].cipher_key_len,
8666                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8667                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8668                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8669                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8670                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8671 }
8672
8673 int
8674 test_pdcp_proto_uplane_encap_with_int(int i)
8675 {
8676         return test_pdcp_proto(
8677                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8678                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8679                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8680                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8681                 pdcp_test_params[i].cipher_key_len,
8682                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8683                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8684                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8685                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8686                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8687 }
8688
8689 int
8690 test_pdcp_proto_cplane_decap(int i)
8691 {
8692         return test_pdcp_proto(
8693                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8694                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8695                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8696                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8697                 pdcp_test_params[i].cipher_key_len,
8698                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8699                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8700                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8701                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8702                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8703 }
8704
8705 int
8706 test_pdcp_proto_uplane_decap(int i)
8707 {
8708         return test_pdcp_proto(
8709                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8710                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8711                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8712                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8713                 pdcp_test_params[i].cipher_key_len,
8714                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8715                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8716                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8717                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8718                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8719 }
8720
8721 int
8722 test_pdcp_proto_uplane_decap_with_int(int i)
8723 {
8724         return test_pdcp_proto(
8725                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8726                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8727                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8728                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8729                 pdcp_test_params[i].cipher_key_len,
8730                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8731                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8732                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8733                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8734                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8735 }
8736
8737 static int
8738 test_PDCP_PROTO_SGL_in_place_32B(void)
8739 {
8740         /* i can be used for running any PDCP case
8741          * In this case it is uplane 12-bit AES-SNOW DL encap
8742          */
8743         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8744         return test_pdcp_proto_SGL(i, IN_PLACE,
8745                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8746                         RTE_CRYPTO_AUTH_OP_GENERATE,
8747                         pdcp_test_data_in[i],
8748                         pdcp_test_data_in_len[i],
8749                         pdcp_test_data_out[i],
8750                         pdcp_test_data_in_len[i]+4,
8751                         32, 0);
8752 }
8753 static int
8754 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8755 {
8756         /* i can be used for running any PDCP case
8757          * In this case it is uplane 18-bit NULL-NULL DL encap
8758          */
8759         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8760         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8761                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8762                         RTE_CRYPTO_AUTH_OP_GENERATE,
8763                         pdcp_test_data_in[i],
8764                         pdcp_test_data_in_len[i],
8765                         pdcp_test_data_out[i],
8766                         pdcp_test_data_in_len[i]+4,
8767                         32, 128);
8768 }
8769 static int
8770 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8771 {
8772         /* i can be used for running any PDCP case
8773          * In this case it is uplane 18-bit AES DL encap
8774          */
8775         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8776                         + DOWNLINK;
8777         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8778                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8779                         RTE_CRYPTO_AUTH_OP_GENERATE,
8780                         pdcp_test_data_in[i],
8781                         pdcp_test_data_in_len[i],
8782                         pdcp_test_data_out[i],
8783                         pdcp_test_data_in_len[i],
8784                         32, 40);
8785 }
8786 static int
8787 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8788 {
8789         /* i can be used for running any PDCP case
8790          * In this case it is cplane 12-bit AES-ZUC DL encap
8791          */
8792         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8793         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8794                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8795                         RTE_CRYPTO_AUTH_OP_GENERATE,
8796                         pdcp_test_data_in[i],
8797                         pdcp_test_data_in_len[i],
8798                         pdcp_test_data_out[i],
8799                         pdcp_test_data_in_len[i]+4,
8800                         128, 32);
8801 }
8802
8803 static int
8804 test_PDCP_SDAP_PROTO_encap_all(void)
8805 {
8806         int i = 0, size = 0;
8807         int err, all_err = TEST_SUCCESS;
8808         const struct pdcp_sdap_test *cur_test;
8809
8810         size = RTE_DIM(list_pdcp_sdap_tests);
8811
8812         for (i = 0; i < size; i++) {
8813                 cur_test = &list_pdcp_sdap_tests[i];
8814                 err = test_pdcp_proto(
8815                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8816                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8817                         cur_test->in_len, cur_test->data_out,
8818                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8819                         cur_test->param.cipher_alg, cur_test->cipher_key,
8820                         cur_test->param.cipher_key_len,
8821                         cur_test->param.auth_alg,
8822                         cur_test->auth_key, cur_test->param.auth_key_len,
8823                         cur_test->bearer, cur_test->param.domain,
8824                         cur_test->packet_direction, cur_test->sn_size,
8825                         cur_test->hfn,
8826                         cur_test->hfn_threshold, SDAP_ENABLED);
8827                 if (err) {
8828                         printf("\t%d) %s: Encapsulation failed\n",
8829                                         cur_test->test_idx,
8830                                         cur_test->param.name);
8831                         err = TEST_FAILED;
8832                 } else {
8833                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8834                                         cur_test->param.name);
8835                         err = TEST_SUCCESS;
8836                 }
8837                 all_err += err;
8838         }
8839
8840         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8841
8842         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8843 }
8844
8845 static int
8846 test_PDCP_PROTO_short_mac(void)
8847 {
8848         int i = 0, size = 0;
8849         int err, all_err = TEST_SUCCESS;
8850         const struct pdcp_short_mac_test *cur_test;
8851
8852         size = RTE_DIM(list_pdcp_smac_tests);
8853
8854         for (i = 0; i < size; i++) {
8855                 cur_test = &list_pdcp_smac_tests[i];
8856                 err = test_pdcp_proto(
8857                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8858                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8859                         cur_test->in_len, cur_test->data_out,
8860                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8861                         RTE_CRYPTO_CIPHER_NULL, NULL,
8862                         0, cur_test->param.auth_alg,
8863                         cur_test->auth_key, cur_test->param.auth_key_len,
8864                         0, cur_test->param.domain, 0, 0,
8865                         0, 0, 0);
8866                 if (err) {
8867                         printf("\t%d) %s: Short MAC test failed\n",
8868                                         cur_test->test_idx,
8869                                         cur_test->param.name);
8870                         err = TEST_FAILED;
8871                 } else {
8872                         printf("\t%d) %s: Short MAC test PASS\n",
8873                                         cur_test->test_idx,
8874                                         cur_test->param.name);
8875                         rte_hexdump(stdout, "MAC I",
8876                                     cur_test->data_out + cur_test->in_len + 2,
8877                                     2);
8878                         err = TEST_SUCCESS;
8879                 }
8880                 all_err += err;
8881         }
8882
8883         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8884
8885         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8886
8887 }
8888
8889 static int
8890 test_PDCP_SDAP_PROTO_decap_all(void)
8891 {
8892         int i = 0, size = 0;
8893         int err, all_err = TEST_SUCCESS;
8894         const struct pdcp_sdap_test *cur_test;
8895
8896         size = RTE_DIM(list_pdcp_sdap_tests);
8897
8898         for (i = 0; i < size; i++) {
8899                 cur_test = &list_pdcp_sdap_tests[i];
8900                 err = test_pdcp_proto(
8901                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8902                         RTE_CRYPTO_AUTH_OP_VERIFY,
8903                         cur_test->data_out,
8904                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8905                         cur_test->data_in, cur_test->in_len,
8906                         cur_test->param.cipher_alg,
8907                         cur_test->cipher_key, cur_test->param.cipher_key_len,
8908                         cur_test->param.auth_alg, cur_test->auth_key,
8909                         cur_test->param.auth_key_len, cur_test->bearer,
8910                         cur_test->param.domain, cur_test->packet_direction,
8911                         cur_test->sn_size, cur_test->hfn,
8912                         cur_test->hfn_threshold, SDAP_ENABLED);
8913                 if (err) {
8914                         printf("\t%d) %s: Decapsulation failed\n",
8915                                         cur_test->test_idx,
8916                                         cur_test->param.name);
8917                         err = TEST_FAILED;
8918                 } else {
8919                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8920                                         cur_test->param.name);
8921                         err = TEST_SUCCESS;
8922                 }
8923                 all_err += err;
8924         }
8925
8926         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8927
8928         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8929 }
8930
8931 static int
8932 test_ipsec_proto_process(const struct ipsec_test_data td[],
8933                          struct ipsec_test_data res_d[],
8934                          int nb_td,
8935                          bool silent,
8936                          const struct ipsec_test_flags *flags)
8937 {
8938         struct crypto_testsuite_params *ts_params = &testsuite_params;
8939         struct crypto_unittest_params *ut_params = &unittest_params;
8940         struct rte_security_capability_idx sec_cap_idx;
8941         const struct rte_security_capability *sec_cap;
8942         struct rte_security_ipsec_xform ipsec_xform;
8943         uint8_t dev_id = ts_params->valid_devs[0];
8944         enum rte_security_ipsec_sa_direction dir;
8945         struct ipsec_test_data *res_d_tmp = NULL;
8946         uint32_t src = RTE_IPV4(192, 168, 1, 0);
8947         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
8948         int salt_len, i, ret = TEST_SUCCESS;
8949         struct rte_security_ctx *ctx;
8950         uint8_t *input_text;
8951         uint32_t verify;
8952
8953         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
8954         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
8955
8956         /* Use first test data to create session */
8957
8958         /* Copy IPsec xform */
8959         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
8960
8961         dir = ipsec_xform.direction;
8962         verify = flags->tunnel_hdr_verify;
8963
8964         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
8965                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
8966                         src += 1;
8967                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
8968                         dst += 1;
8969         }
8970
8971         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src));
8972         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst));
8973
8974         ctx = rte_cryptodev_get_sec_ctx(dev_id);
8975
8976         sec_cap_idx.action = ut_params->type;
8977         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
8978         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
8979         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
8980         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
8981
8982         if (flags->udp_encap)
8983                 ipsec_xform.options.udp_encap = 1;
8984
8985         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8986         if (sec_cap == NULL)
8987                 return TEST_SKIPPED;
8988
8989         /* Copy cipher session parameters */
8990         if (td[0].aead) {
8991                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
8992                        sizeof(ut_params->aead_xform));
8993                 ut_params->aead_xform.aead.key.data = td[0].key.data;
8994                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8995
8996                 /* Verify crypto capabilities */
8997                 if (test_ipsec_crypto_caps_aead_verify(
8998                                 sec_cap,
8999                                 &ut_params->aead_xform) != 0) {
9000                         if (!silent)
9001                                 RTE_LOG(INFO, USER1,
9002                                         "Crypto capabilities not supported\n");
9003                         return TEST_SKIPPED;
9004                 }
9005         } else {
9006                 /* Only AEAD supported now */
9007                 return TEST_SKIPPED;
9008         }
9009
9010         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9011                 return TEST_SKIPPED;
9012
9013         salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9014         memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9015
9016         struct rte_security_session_conf sess_conf = {
9017                 .action_type = ut_params->type,
9018                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9019                 .ipsec = ipsec_xform,
9020                 .crypto_xform = &ut_params->aead_xform,
9021         };
9022
9023         /* Create security session */
9024         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9025                                         ts_params->session_mpool,
9026                                         ts_params->session_priv_mpool);
9027
9028         if (ut_params->sec_session == NULL)
9029                 return TEST_SKIPPED;
9030
9031         for (i = 0; i < nb_td; i++) {
9032                 /* Setup source mbuf payload */
9033                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9034                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9035                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9036
9037                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9038                                 td[i].input_text.len);
9039
9040                 memcpy(input_text, td[i].input_text.data,
9041                        td[i].input_text.len);
9042
9043                 /* Generate crypto op data structure */
9044                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9045                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9046                 if (!ut_params->op) {
9047                         printf("TestCase %s line %d: %s\n",
9048                                 __func__, __LINE__,
9049                                 "failed to allocate crypto op");
9050                         ret = TEST_FAILED;
9051                         goto crypto_op_free;
9052                 }
9053
9054                 /* Attach session to operation */
9055                 rte_security_attach_session(ut_params->op,
9056                                             ut_params->sec_session);
9057
9058                 /* Set crypto operation mbufs */
9059                 ut_params->op->sym->m_src = ut_params->ibuf;
9060                 ut_params->op->sym->m_dst = NULL;
9061
9062                 /* Copy IV in crypto operation when IV generation is disabled */
9063                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9064                     ipsec_xform.options.iv_gen_disable == 1) {
9065                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9066                                                                 uint8_t *,
9067                                                                 IV_OFFSET);
9068                         int len;
9069
9070                         if (td[i].aead)
9071                                 len = td[i].xform.aead.aead.iv.length;
9072                         else
9073                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9074
9075                         memcpy(iv, td[i].iv.data, len);
9076                 }
9077
9078                 /* Process crypto operation */
9079                 process_crypto_request(dev_id, ut_params->op);
9080
9081                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9082                 if (ret != TEST_SUCCESS)
9083                         goto crypto_op_free;
9084
9085                 if (res_d != NULL)
9086                         res_d_tmp = &res_d[i];
9087
9088                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9089                                               res_d_tmp, silent, flags);
9090                 if (ret != TEST_SUCCESS)
9091                         goto crypto_op_free;
9092
9093                 rte_crypto_op_free(ut_params->op);
9094                 ut_params->op = NULL;
9095
9096                 rte_pktmbuf_free(ut_params->ibuf);
9097                 ut_params->ibuf = NULL;
9098         }
9099
9100 crypto_op_free:
9101         rte_crypto_op_free(ut_params->op);
9102         ut_params->op = NULL;
9103
9104         rte_pktmbuf_free(ut_params->ibuf);
9105         ut_params->ibuf = NULL;
9106
9107         if (ut_params->sec_session)
9108                 rte_security_session_destroy(ctx, ut_params->sec_session);
9109         ut_params->sec_session = NULL;
9110
9111         return ret;
9112 }
9113
9114 static int
9115 test_ipsec_proto_known_vec(const void *test_data)
9116 {
9117         struct ipsec_test_data td_outb;
9118         struct ipsec_test_flags flags;
9119
9120         memset(&flags, 0, sizeof(flags));
9121
9122         memcpy(&td_outb, test_data, sizeof(td_outb));
9123
9124         /* Disable IV gen to be able to test with known vectors */
9125         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9126
9127         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9128 }
9129
9130 static int
9131 test_ipsec_proto_known_vec_inb(const void *td_outb)
9132 {
9133         struct ipsec_test_flags flags;
9134         struct ipsec_test_data td_inb;
9135
9136         memset(&flags, 0, sizeof(flags));
9137
9138         test_ipsec_td_in_from_out(td_outb, &td_inb);
9139
9140         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9141 }
9142
9143 static int
9144 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9145 {
9146         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9147         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9148         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9149         int ret;
9150
9151         if (flags->iv_gen ||
9152             flags->sa_expiry_pkts_soft ||
9153             flags->sa_expiry_pkts_hard)
9154                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9155
9156         for (i = 0; i < RTE_DIM(aead_list); i++) {
9157                 test_ipsec_td_prepare(&aead_list[i],
9158                                       NULL,
9159                                       flags,
9160                                       td_outb,
9161                                       nb_pkts);
9162
9163                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9164                                                flags);
9165                 if (ret == TEST_SKIPPED)
9166                         continue;
9167
9168                 if (ret == TEST_FAILED)
9169                         return TEST_FAILED;
9170
9171                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9172
9173                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9174                                                flags);
9175                 if (ret == TEST_SKIPPED)
9176                         continue;
9177
9178                 if (ret == TEST_FAILED)
9179                         return TEST_FAILED;
9180
9181                 if (flags->display_alg)
9182                         test_ipsec_display_alg(&aead_list[i], NULL);
9183
9184                 pass_cnt++;
9185         }
9186
9187         if (pass_cnt > 0)
9188                 return TEST_SUCCESS;
9189         else
9190                 return TEST_SKIPPED;
9191 }
9192
9193 static int
9194 test_ipsec_proto_display_list(const void *data __rte_unused)
9195 {
9196         struct ipsec_test_flags flags;
9197
9198         memset(&flags, 0, sizeof(flags));
9199
9200         flags.display_alg = true;
9201
9202         return test_ipsec_proto_all(&flags);
9203 }
9204
9205 static int
9206 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9207 {
9208         struct ipsec_test_flags flags;
9209
9210         memset(&flags, 0, sizeof(flags));
9211
9212         flags.iv_gen = true;
9213
9214         return test_ipsec_proto_all(&flags);
9215 }
9216
9217 static int
9218 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9219 {
9220         struct ipsec_test_flags flags;
9221
9222         memset(&flags, 0, sizeof(flags));
9223
9224         flags.sa_expiry_pkts_soft = true;
9225
9226         return test_ipsec_proto_all(&flags);
9227 }
9228
9229 static int
9230 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9231 {
9232         struct ipsec_test_flags flags;
9233
9234         memset(&flags, 0, sizeof(flags));
9235
9236         flags.sa_expiry_pkts_hard = true;
9237
9238         return test_ipsec_proto_all(&flags);
9239 }
9240
9241 static int
9242 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9243 {
9244         struct ipsec_test_flags flags;
9245
9246         memset(&flags, 0, sizeof(flags));
9247
9248         flags.icv_corrupt = true;
9249
9250         return test_ipsec_proto_all(&flags);
9251 }
9252
9253 static int
9254 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9255 {
9256         struct ipsec_test_flags flags;
9257
9258         memset(&flags, 0, sizeof(flags));
9259
9260         flags.udp_encap = true;
9261
9262         return test_ipsec_proto_all(&flags);
9263 }
9264
9265 static int
9266 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9267 {
9268         struct ipsec_test_flags flags;
9269
9270         memset(&flags, 0, sizeof(flags));
9271
9272         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9273
9274         return test_ipsec_proto_all(&flags);
9275 }
9276
9277 static int
9278 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9279 {
9280         struct ipsec_test_flags flags;
9281
9282         memset(&flags, 0, sizeof(flags));
9283
9284         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9285
9286         return test_ipsec_proto_all(&flags);
9287 }
9288
9289 static int
9290 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9291 {
9292         struct ipsec_test_flags flags;
9293
9294         memset(&flags, 0, sizeof(flags));
9295
9296         flags.udp_encap = true;
9297         flags.udp_ports_verify = true;
9298
9299         return test_ipsec_proto_all(&flags);
9300 }
9301
9302 static int
9303 test_PDCP_PROTO_all(void)
9304 {
9305         struct crypto_testsuite_params *ts_params = &testsuite_params;
9306         struct crypto_unittest_params *ut_params = &unittest_params;
9307         struct rte_cryptodev_info dev_info;
9308         int status;
9309
9310         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9311         uint64_t feat_flags = dev_info.feature_flags;
9312
9313         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9314                 return TEST_SKIPPED;
9315
9316         /* Set action type */
9317         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9318                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9319                 gbl_action_type;
9320
9321         if (security_proto_supported(ut_params->type,
9322                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9323                 return TEST_SKIPPED;
9324
9325         status = test_PDCP_PROTO_cplane_encap_all();
9326         status += test_PDCP_PROTO_cplane_decap_all();
9327         status += test_PDCP_PROTO_uplane_encap_all();
9328         status += test_PDCP_PROTO_uplane_decap_all();
9329         status += test_PDCP_PROTO_SGL_in_place_32B();
9330         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9331         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9332         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9333         status += test_PDCP_SDAP_PROTO_encap_all();
9334         status += test_PDCP_SDAP_PROTO_decap_all();
9335         status += test_PDCP_PROTO_short_mac();
9336
9337         if (status)
9338                 return TEST_FAILED;
9339         else
9340                 return TEST_SUCCESS;
9341 }
9342
9343 static int
9344 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
9345 {
9346         struct crypto_testsuite_params *ts_params = &testsuite_params;
9347         struct crypto_unittest_params *ut_params = &unittest_params;
9348         uint8_t *plaintext, *ciphertext;
9349         uint8_t *iv_ptr;
9350         int32_t cipher_len, crc_len;
9351         uint32_t crc_data_len;
9352         int ret = TEST_SUCCESS;
9353
9354         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9355                                         rte_cryptodev_get_sec_ctx(
9356                                                 ts_params->valid_devs[0]);
9357
9358         /* Verify the capabilities */
9359         struct rte_security_capability_idx sec_cap_idx;
9360         const struct rte_security_capability *sec_cap;
9361         const struct rte_cryptodev_capabilities *crypto_cap;
9362         const struct rte_cryptodev_symmetric_capability *sym_cap;
9363         int j = 0;
9364
9365         sec_cap_idx.action = ut_params->type;
9366         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9367         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9368
9369         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9370         if (sec_cap == NULL)
9371                 return TEST_SKIPPED;
9372
9373         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9374                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9375                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9376                                 crypto_cap->sym.xform_type ==
9377                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9378                                 crypto_cap->sym.cipher.algo ==
9379                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9380                         sym_cap = &crypto_cap->sym;
9381                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9382                                                 d_td->key.len,
9383                                                 d_td->iv.len) == 0)
9384                                 break;
9385                 }
9386         }
9387
9388         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9389                 return TEST_SKIPPED;
9390
9391         /* Setup source mbuf payload */
9392         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9393         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9394                         rte_pktmbuf_tailroom(ut_params->ibuf));
9395
9396         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9397                         d_td->ciphertext.len);
9398
9399         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9400
9401         /* Setup cipher session parameters */
9402         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9403         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9404         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9405         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9406         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9407         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9408         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9409         ut_params->cipher_xform.next = NULL;
9410
9411         /* Setup DOCSIS session parameters */
9412         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9413
9414         struct rte_security_session_conf sess_conf = {
9415                 .action_type = ut_params->type,
9416                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9417                 .docsis = ut_params->docsis_xform,
9418                 .crypto_xform = &ut_params->cipher_xform,
9419         };
9420
9421         /* Create security session */
9422         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9423                                         ts_params->session_mpool,
9424                                         ts_params->session_priv_mpool);
9425
9426         if (!ut_params->sec_session) {
9427                 printf("TestCase %s(%d) line %d: %s\n",
9428                         __func__, i, __LINE__, "failed to allocate session");
9429                 ret = TEST_FAILED;
9430                 goto on_err;
9431         }
9432
9433         /* Generate crypto op data structure */
9434         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9435                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9436         if (!ut_params->op) {
9437                 printf("TestCase %s(%d) line %d: %s\n",
9438                         __func__, i, __LINE__,
9439                         "failed to allocate symmetric crypto operation");
9440                 ret = TEST_FAILED;
9441                 goto on_err;
9442         }
9443
9444         /* Setup CRC operation parameters */
9445         crc_len = d_td->ciphertext.no_crc == false ?
9446                         (d_td->ciphertext.len -
9447                                 d_td->ciphertext.crc_offset -
9448                                 RTE_ETHER_CRC_LEN) :
9449                         0;
9450         crc_len = crc_len > 0 ? crc_len : 0;
9451         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9452         ut_params->op->sym->auth.data.length = crc_len;
9453         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9454
9455         /* Setup cipher operation parameters */
9456         cipher_len = d_td->ciphertext.no_cipher == false ?
9457                         (d_td->ciphertext.len -
9458                                 d_td->ciphertext.cipher_offset) :
9459                         0;
9460         cipher_len = cipher_len > 0 ? cipher_len : 0;
9461         ut_params->op->sym->cipher.data.length = cipher_len;
9462         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9463
9464         /* Setup cipher IV */
9465         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9466         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9467
9468         /* Attach session to operation */
9469         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9470
9471         /* Set crypto operation mbufs */
9472         ut_params->op->sym->m_src = ut_params->ibuf;
9473         ut_params->op->sym->m_dst = NULL;
9474
9475         /* Process crypto operation */
9476         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9477                         NULL) {
9478                 printf("TestCase %s(%d) line %d: %s\n",
9479                         __func__, i, __LINE__,
9480                         "failed to process security crypto op");
9481                 ret = TEST_FAILED;
9482                 goto on_err;
9483         }
9484
9485         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9486                 printf("TestCase %s(%d) line %d: %s\n",
9487                         __func__, i, __LINE__, "crypto op processing failed");
9488                 ret = TEST_FAILED;
9489                 goto on_err;
9490         }
9491
9492         /* Validate plaintext */
9493         plaintext = ciphertext;
9494
9495         if (memcmp(plaintext, d_td->plaintext.data,
9496                         d_td->plaintext.len - crc_data_len)) {
9497                 printf("TestCase %s(%d) line %d: %s\n",
9498                         __func__, i, __LINE__, "plaintext not as expected\n");
9499                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9500                                 d_td->plaintext.len);
9501                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9502                 ret = TEST_FAILED;
9503                 goto on_err;
9504         }
9505
9506 on_err:
9507         rte_crypto_op_free(ut_params->op);
9508         ut_params->op = NULL;
9509
9510         if (ut_params->sec_session)
9511                 rte_security_session_destroy(ctx, ut_params->sec_session);
9512         ut_params->sec_session = NULL;
9513
9514         rte_pktmbuf_free(ut_params->ibuf);
9515         ut_params->ibuf = NULL;
9516
9517         return ret;
9518 }
9519
9520 static int
9521 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
9522 {
9523         struct crypto_testsuite_params *ts_params = &testsuite_params;
9524         struct crypto_unittest_params *ut_params = &unittest_params;
9525         uint8_t *plaintext, *ciphertext;
9526         uint8_t *iv_ptr;
9527         int32_t cipher_len, crc_len;
9528         int ret = TEST_SUCCESS;
9529
9530         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9531                                         rte_cryptodev_get_sec_ctx(
9532                                                 ts_params->valid_devs[0]);
9533
9534         /* Verify the capabilities */
9535         struct rte_security_capability_idx sec_cap_idx;
9536         const struct rte_security_capability *sec_cap;
9537         const struct rte_cryptodev_capabilities *crypto_cap;
9538         const struct rte_cryptodev_symmetric_capability *sym_cap;
9539         int j = 0;
9540
9541         sec_cap_idx.action = ut_params->type;
9542         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9543         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9544
9545         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9546         if (sec_cap == NULL)
9547                 return TEST_SKIPPED;
9548
9549         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9550                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9551                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9552                                 crypto_cap->sym.xform_type ==
9553                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9554                                 crypto_cap->sym.cipher.algo ==
9555                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9556                         sym_cap = &crypto_cap->sym;
9557                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9558                                                 d_td->key.len,
9559                                                 d_td->iv.len) == 0)
9560                                 break;
9561                 }
9562         }
9563
9564         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9565                 return TEST_SKIPPED;
9566
9567         /* Setup source mbuf payload */
9568         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9569         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9570                         rte_pktmbuf_tailroom(ut_params->ibuf));
9571
9572         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9573                         d_td->plaintext.len);
9574
9575         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9576
9577         /* Setup cipher session parameters */
9578         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9579         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9580         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9581         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9582         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9583         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9584         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9585         ut_params->cipher_xform.next = NULL;
9586
9587         /* Setup DOCSIS session parameters */
9588         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9589
9590         struct rte_security_session_conf sess_conf = {
9591                 .action_type = ut_params->type,
9592                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9593                 .docsis = ut_params->docsis_xform,
9594                 .crypto_xform = &ut_params->cipher_xform,
9595         };
9596
9597         /* Create security session */
9598         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9599                                         ts_params->session_mpool,
9600                                         ts_params->session_priv_mpool);
9601
9602         if (!ut_params->sec_session) {
9603                 printf("TestCase %s(%d) line %d: %s\n",
9604                         __func__, i, __LINE__, "failed to allocate session");
9605                 ret = TEST_FAILED;
9606                 goto on_err;
9607         }
9608
9609         /* Generate crypto op data structure */
9610         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9611                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9612         if (!ut_params->op) {
9613                 printf("TestCase %s(%d) line %d: %s\n",
9614                         __func__, i, __LINE__,
9615                         "failed to allocate security crypto operation");
9616                 ret = TEST_FAILED;
9617                 goto on_err;
9618         }
9619
9620         /* Setup CRC operation parameters */
9621         crc_len = d_td->plaintext.no_crc == false ?
9622                         (d_td->plaintext.len -
9623                                 d_td->plaintext.crc_offset -
9624                                 RTE_ETHER_CRC_LEN) :
9625                         0;
9626         crc_len = crc_len > 0 ? crc_len : 0;
9627         ut_params->op->sym->auth.data.length = crc_len;
9628         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
9629
9630         /* Setup cipher operation parameters */
9631         cipher_len = d_td->plaintext.no_cipher == false ?
9632                         (d_td->plaintext.len -
9633                                 d_td->plaintext.cipher_offset) :
9634                         0;
9635         cipher_len = cipher_len > 0 ? cipher_len : 0;
9636         ut_params->op->sym->cipher.data.length = cipher_len;
9637         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
9638
9639         /* Setup cipher IV */
9640         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9641         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9642
9643         /* Attach session to operation */
9644         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9645
9646         /* Set crypto operation mbufs */
9647         ut_params->op->sym->m_src = ut_params->ibuf;
9648         ut_params->op->sym->m_dst = NULL;
9649
9650         /* Process crypto operation */
9651         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9652                         NULL) {
9653                 printf("TestCase %s(%d) line %d: %s\n",
9654                         __func__, i, __LINE__,
9655                         "failed to process security crypto op");
9656                 ret = TEST_FAILED;
9657                 goto on_err;
9658         }
9659
9660         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9661                 printf("TestCase %s(%d) line %d: %s\n",
9662                         __func__, i, __LINE__, "crypto op processing failed");
9663                 ret = TEST_FAILED;
9664                 goto on_err;
9665         }
9666
9667         /* Validate ciphertext */
9668         ciphertext = plaintext;
9669
9670         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
9671                 printf("TestCase %s(%d) line %d: %s\n",
9672                         __func__, i, __LINE__, "ciphertext not as expected\n");
9673                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
9674                                 d_td->ciphertext.len);
9675                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
9676                 ret = TEST_FAILED;
9677                 goto on_err;
9678         }
9679
9680 on_err:
9681         rte_crypto_op_free(ut_params->op);
9682         ut_params->op = NULL;
9683
9684         if (ut_params->sec_session)
9685                 rte_security_session_destroy(ctx, ut_params->sec_session);
9686         ut_params->sec_session = NULL;
9687
9688         rte_pktmbuf_free(ut_params->ibuf);
9689         ut_params->ibuf = NULL;
9690
9691         return ret;
9692 }
9693
9694 #define TEST_DOCSIS_COUNT(func) do {                    \
9695         int ret = func;                                 \
9696         if (ret == TEST_SUCCESS)  {                     \
9697                 printf("\t%2d)", n++);                  \
9698                 printf("+++++ PASSED:" #func"\n");      \
9699                 p++;                                    \
9700         } else if (ret == TEST_SKIPPED) {               \
9701                 printf("\t%2d)", n++);                  \
9702                 printf("~~~~~ SKIPPED:" #func"\n");     \
9703                 s++;                                    \
9704         } else {                                        \
9705                 printf("\t%2d)", n++);                  \
9706                 printf("----- FAILED:" #func"\n");      \
9707                 f++;                                    \
9708         }                                               \
9709 } while (0)
9710
9711 static int
9712 test_DOCSIS_PROTO_uplink_all(void)
9713 {
9714         int p = 0, s = 0, f = 0, n = 0;
9715
9716         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
9717         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
9718         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
9719         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
9720         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
9721         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
9722         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
9723         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
9724         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
9725         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
9726         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
9727         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
9728         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
9729         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
9730         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
9731         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
9732         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
9733         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
9734         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
9735         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
9736         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
9737         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
9738         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
9739         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
9740         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
9741         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
9742
9743         if (f)
9744                 printf("## %s: %d passed out of %d (%d skipped)\n",
9745                         __func__, p, n, s);
9746
9747         return f;
9748 };
9749
9750 static int
9751 test_DOCSIS_PROTO_downlink_all(void)
9752 {
9753         int p = 0, s = 0, f = 0, n = 0;
9754
9755         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
9756         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
9757         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
9758         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
9759         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
9760         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
9761         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
9762         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
9763         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
9764         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
9765         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
9766         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
9767         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
9768         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
9769         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
9770         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
9771         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
9772         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
9773         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
9774         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
9775         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
9776         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
9777         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
9778         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
9779         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
9780         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
9781
9782         if (f)
9783                 printf("## %s: %d passed out of %d (%d skipped)\n",
9784                         __func__, p, n, s);
9785
9786         return f;
9787 };
9788
9789 static int
9790 test_DOCSIS_PROTO_all(void)
9791 {
9792         struct crypto_testsuite_params *ts_params = &testsuite_params;
9793         struct crypto_unittest_params *ut_params = &unittest_params;
9794         struct rte_cryptodev_info dev_info;
9795         int status;
9796
9797         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9798         uint64_t feat_flags = dev_info.feature_flags;
9799
9800         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9801                 return TEST_SKIPPED;
9802
9803         /* Set action type */
9804         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9805                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9806                 gbl_action_type;
9807
9808         if (security_proto_supported(ut_params->type,
9809                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9810                 return TEST_SKIPPED;
9811
9812         status = test_DOCSIS_PROTO_uplink_all();
9813         status += test_DOCSIS_PROTO_downlink_all();
9814
9815         if (status)
9816                 return TEST_FAILED;
9817         else
9818                 return TEST_SUCCESS;
9819 }
9820 #endif
9821
9822 static int
9823 test_AES_GCM_authenticated_encryption_test_case_1(void)
9824 {
9825         return test_authenticated_encryption(&gcm_test_case_1);
9826 }
9827
9828 static int
9829 test_AES_GCM_authenticated_encryption_test_case_2(void)
9830 {
9831         return test_authenticated_encryption(&gcm_test_case_2);
9832 }
9833
9834 static int
9835 test_AES_GCM_authenticated_encryption_test_case_3(void)
9836 {
9837         return test_authenticated_encryption(&gcm_test_case_3);
9838 }
9839
9840 static int
9841 test_AES_GCM_authenticated_encryption_test_case_4(void)
9842 {
9843         return test_authenticated_encryption(&gcm_test_case_4);
9844 }
9845
9846 static int
9847 test_AES_GCM_authenticated_encryption_test_case_5(void)
9848 {
9849         return test_authenticated_encryption(&gcm_test_case_5);
9850 }
9851
9852 static int
9853 test_AES_GCM_authenticated_encryption_test_case_6(void)
9854 {
9855         return test_authenticated_encryption(&gcm_test_case_6);
9856 }
9857
9858 static int
9859 test_AES_GCM_authenticated_encryption_test_case_7(void)
9860 {
9861         return test_authenticated_encryption(&gcm_test_case_7);
9862 }
9863
9864 static int
9865 test_AES_GCM_authenticated_encryption_test_case_8(void)
9866 {
9867         return test_authenticated_encryption(&gcm_test_case_8);
9868 }
9869
9870 static int
9871 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9872 {
9873         return test_authenticated_encryption(&gcm_J0_test_case_1);
9874 }
9875
9876 static int
9877 test_AES_GCM_auth_encryption_test_case_192_1(void)
9878 {
9879         return test_authenticated_encryption(&gcm_test_case_192_1);
9880 }
9881
9882 static int
9883 test_AES_GCM_auth_encryption_test_case_192_2(void)
9884 {
9885         return test_authenticated_encryption(&gcm_test_case_192_2);
9886 }
9887
9888 static int
9889 test_AES_GCM_auth_encryption_test_case_192_3(void)
9890 {
9891         return test_authenticated_encryption(&gcm_test_case_192_3);
9892 }
9893
9894 static int
9895 test_AES_GCM_auth_encryption_test_case_192_4(void)
9896 {
9897         return test_authenticated_encryption(&gcm_test_case_192_4);
9898 }
9899
9900 static int
9901 test_AES_GCM_auth_encryption_test_case_192_5(void)
9902 {
9903         return test_authenticated_encryption(&gcm_test_case_192_5);
9904 }
9905
9906 static int
9907 test_AES_GCM_auth_encryption_test_case_192_6(void)
9908 {
9909         return test_authenticated_encryption(&gcm_test_case_192_6);
9910 }
9911
9912 static int
9913 test_AES_GCM_auth_encryption_test_case_192_7(void)
9914 {
9915         return test_authenticated_encryption(&gcm_test_case_192_7);
9916 }
9917
9918 static int
9919 test_AES_GCM_auth_encryption_test_case_256_1(void)
9920 {
9921         return test_authenticated_encryption(&gcm_test_case_256_1);
9922 }
9923
9924 static int
9925 test_AES_GCM_auth_encryption_test_case_256_2(void)
9926 {
9927         return test_authenticated_encryption(&gcm_test_case_256_2);
9928 }
9929
9930 static int
9931 test_AES_GCM_auth_encryption_test_case_256_3(void)
9932 {
9933         return test_authenticated_encryption(&gcm_test_case_256_3);
9934 }
9935
9936 static int
9937 test_AES_GCM_auth_encryption_test_case_256_4(void)
9938 {
9939         return test_authenticated_encryption(&gcm_test_case_256_4);
9940 }
9941
9942 static int
9943 test_AES_GCM_auth_encryption_test_case_256_5(void)
9944 {
9945         return test_authenticated_encryption(&gcm_test_case_256_5);
9946 }
9947
9948 static int
9949 test_AES_GCM_auth_encryption_test_case_256_6(void)
9950 {
9951         return test_authenticated_encryption(&gcm_test_case_256_6);
9952 }
9953
9954 static int
9955 test_AES_GCM_auth_encryption_test_case_256_7(void)
9956 {
9957         return test_authenticated_encryption(&gcm_test_case_256_7);
9958 }
9959
9960 static int
9961 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9962 {
9963         return test_authenticated_encryption(&gcm_test_case_aad_1);
9964 }
9965
9966 static int
9967 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9968 {
9969         return test_authenticated_encryption(&gcm_test_case_aad_2);
9970 }
9971
9972 static int
9973 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9974 {
9975         struct aead_test_data tdata;
9976         int res;
9977
9978         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9979         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9980         tdata.iv.data[0] += 1;
9981         res = test_authenticated_encryption(&tdata);
9982         if (res == TEST_SKIPPED)
9983                 return res;
9984         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9985         return TEST_SUCCESS;
9986 }
9987
9988 static int
9989 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9990 {
9991         struct aead_test_data tdata;
9992         int res;
9993
9994         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9995         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9996         tdata.plaintext.data[0] += 1;
9997         res = test_authenticated_encryption(&tdata);
9998         if (res == TEST_SKIPPED)
9999                 return res;
10000         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10001         return TEST_SUCCESS;
10002 }
10003
10004 static int
10005 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10006 {
10007         struct aead_test_data tdata;
10008         int res;
10009
10010         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10011         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10012         tdata.ciphertext.data[0] += 1;
10013         res = test_authenticated_encryption(&tdata);
10014         if (res == TEST_SKIPPED)
10015                 return res;
10016         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10017         return TEST_SUCCESS;
10018 }
10019
10020 static int
10021 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10022 {
10023         struct aead_test_data tdata;
10024         int res;
10025
10026         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10027         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10028         tdata.aad.len += 1;
10029         res = test_authenticated_encryption(&tdata);
10030         if (res == TEST_SKIPPED)
10031                 return res;
10032         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10033         return TEST_SUCCESS;
10034 }
10035
10036 static int
10037 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10038 {
10039         struct aead_test_data tdata;
10040         uint8_t aad[gcm_test_case_7.aad.len];
10041         int res;
10042
10043         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10044         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10045         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10046         aad[0] += 1;
10047         tdata.aad.data = aad;
10048         res = test_authenticated_encryption(&tdata);
10049         if (res == TEST_SKIPPED)
10050                 return res;
10051         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10052         return TEST_SUCCESS;
10053 }
10054
10055 static int
10056 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10057 {
10058         struct aead_test_data tdata;
10059         int res;
10060
10061         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10062         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10063         tdata.auth_tag.data[0] += 1;
10064         res = test_authenticated_encryption(&tdata);
10065         if (res == TEST_SKIPPED)
10066                 return res;
10067         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10068         return TEST_SUCCESS;
10069 }
10070
10071 static int
10072 test_authenticated_decryption(const struct aead_test_data *tdata)
10073 {
10074         struct crypto_testsuite_params *ts_params = &testsuite_params;
10075         struct crypto_unittest_params *ut_params = &unittest_params;
10076
10077         int retval;
10078         uint8_t *plaintext;
10079         uint32_t i;
10080         struct rte_cryptodev_info dev_info;
10081
10082         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10083         uint64_t feat_flags = dev_info.feature_flags;
10084
10085         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10086                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10087                 printf("Device doesn't support RAW data-path APIs.\n");
10088                 return TEST_SKIPPED;
10089         }
10090
10091         /* Verify the capabilities */
10092         struct rte_cryptodev_sym_capability_idx cap_idx;
10093         const struct rte_cryptodev_symmetric_capability *capability;
10094         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10095         cap_idx.algo.aead = tdata->algo;
10096         capability = rte_cryptodev_sym_capability_get(
10097                         ts_params->valid_devs[0], &cap_idx);
10098         if (capability == NULL)
10099                 return TEST_SKIPPED;
10100         if (rte_cryptodev_sym_capability_check_aead(
10101                         capability, tdata->key.len, tdata->auth_tag.len,
10102                         tdata->aad.len, tdata->iv.len))
10103                 return TEST_SKIPPED;
10104
10105         /* Create AEAD session */
10106         retval = create_aead_session(ts_params->valid_devs[0],
10107                         tdata->algo,
10108                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10109                         tdata->key.data, tdata->key.len,
10110                         tdata->aad.len, tdata->auth_tag.len,
10111                         tdata->iv.len);
10112         if (retval < 0)
10113                 return retval;
10114
10115         /* alloc mbuf and set payload */
10116         if (tdata->aad.len > MBUF_SIZE) {
10117                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10118                 /* Populate full size of add data */
10119                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10120                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10121         } else
10122                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10123
10124         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10125                         rte_pktmbuf_tailroom(ut_params->ibuf));
10126
10127         /* Create AEAD operation */
10128         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10129         if (retval < 0)
10130                 return retval;
10131
10132         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10133
10134         ut_params->op->sym->m_src = ut_params->ibuf;
10135
10136         /* Process crypto operation */
10137         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10138                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10139         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10140                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10141                                 ut_params->op, 0, 0, 0, 0);
10142         else
10143                 TEST_ASSERT_NOT_NULL(
10144                         process_crypto_request(ts_params->valid_devs[0],
10145                         ut_params->op), "failed to process sym crypto op");
10146
10147         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10148                         "crypto op processing failed");
10149
10150         if (ut_params->op->sym->m_dst)
10151                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10152                                 uint8_t *);
10153         else
10154                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10155                                 uint8_t *,
10156                                 ut_params->op->sym->cipher.data.offset);
10157
10158         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10159
10160         /* Validate obuf */
10161         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10162                         plaintext,
10163                         tdata->plaintext.data,
10164                         tdata->plaintext.len,
10165                         "Plaintext data not as expected");
10166
10167         TEST_ASSERT_EQUAL(ut_params->op->status,
10168                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10169                         "Authentication failed");
10170
10171         return 0;
10172 }
10173
10174 static int
10175 test_AES_GCM_authenticated_decryption_test_case_1(void)
10176 {
10177         return test_authenticated_decryption(&gcm_test_case_1);
10178 }
10179
10180 static int
10181 test_AES_GCM_authenticated_decryption_test_case_2(void)
10182 {
10183         return test_authenticated_decryption(&gcm_test_case_2);
10184 }
10185
10186 static int
10187 test_AES_GCM_authenticated_decryption_test_case_3(void)
10188 {
10189         return test_authenticated_decryption(&gcm_test_case_3);
10190 }
10191
10192 static int
10193 test_AES_GCM_authenticated_decryption_test_case_4(void)
10194 {
10195         return test_authenticated_decryption(&gcm_test_case_4);
10196 }
10197
10198 static int
10199 test_AES_GCM_authenticated_decryption_test_case_5(void)
10200 {
10201         return test_authenticated_decryption(&gcm_test_case_5);
10202 }
10203
10204 static int
10205 test_AES_GCM_authenticated_decryption_test_case_6(void)
10206 {
10207         return test_authenticated_decryption(&gcm_test_case_6);
10208 }
10209
10210 static int
10211 test_AES_GCM_authenticated_decryption_test_case_7(void)
10212 {
10213         return test_authenticated_decryption(&gcm_test_case_7);
10214 }
10215
10216 static int
10217 test_AES_GCM_authenticated_decryption_test_case_8(void)
10218 {
10219         return test_authenticated_decryption(&gcm_test_case_8);
10220 }
10221
10222 static int
10223 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10224 {
10225         return test_authenticated_decryption(&gcm_J0_test_case_1);
10226 }
10227
10228 static int
10229 test_AES_GCM_auth_decryption_test_case_192_1(void)
10230 {
10231         return test_authenticated_decryption(&gcm_test_case_192_1);
10232 }
10233
10234 static int
10235 test_AES_GCM_auth_decryption_test_case_192_2(void)
10236 {
10237         return test_authenticated_decryption(&gcm_test_case_192_2);
10238 }
10239
10240 static int
10241 test_AES_GCM_auth_decryption_test_case_192_3(void)
10242 {
10243         return test_authenticated_decryption(&gcm_test_case_192_3);
10244 }
10245
10246 static int
10247 test_AES_GCM_auth_decryption_test_case_192_4(void)
10248 {
10249         return test_authenticated_decryption(&gcm_test_case_192_4);
10250 }
10251
10252 static int
10253 test_AES_GCM_auth_decryption_test_case_192_5(void)
10254 {
10255         return test_authenticated_decryption(&gcm_test_case_192_5);
10256 }
10257
10258 static int
10259 test_AES_GCM_auth_decryption_test_case_192_6(void)
10260 {
10261         return test_authenticated_decryption(&gcm_test_case_192_6);
10262 }
10263
10264 static int
10265 test_AES_GCM_auth_decryption_test_case_192_7(void)
10266 {
10267         return test_authenticated_decryption(&gcm_test_case_192_7);
10268 }
10269
10270 static int
10271 test_AES_GCM_auth_decryption_test_case_256_1(void)
10272 {
10273         return test_authenticated_decryption(&gcm_test_case_256_1);
10274 }
10275
10276 static int
10277 test_AES_GCM_auth_decryption_test_case_256_2(void)
10278 {
10279         return test_authenticated_decryption(&gcm_test_case_256_2);
10280 }
10281
10282 static int
10283 test_AES_GCM_auth_decryption_test_case_256_3(void)
10284 {
10285         return test_authenticated_decryption(&gcm_test_case_256_3);
10286 }
10287
10288 static int
10289 test_AES_GCM_auth_decryption_test_case_256_4(void)
10290 {
10291         return test_authenticated_decryption(&gcm_test_case_256_4);
10292 }
10293
10294 static int
10295 test_AES_GCM_auth_decryption_test_case_256_5(void)
10296 {
10297         return test_authenticated_decryption(&gcm_test_case_256_5);
10298 }
10299
10300 static int
10301 test_AES_GCM_auth_decryption_test_case_256_6(void)
10302 {
10303         return test_authenticated_decryption(&gcm_test_case_256_6);
10304 }
10305
10306 static int
10307 test_AES_GCM_auth_decryption_test_case_256_7(void)
10308 {
10309         return test_authenticated_decryption(&gcm_test_case_256_7);
10310 }
10311
10312 static int
10313 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10314 {
10315         return test_authenticated_decryption(&gcm_test_case_aad_1);
10316 }
10317
10318 static int
10319 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10320 {
10321         return test_authenticated_decryption(&gcm_test_case_aad_2);
10322 }
10323
10324 static int
10325 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10326 {
10327         struct aead_test_data tdata;
10328         int res;
10329
10330         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10331         tdata.iv.data[0] += 1;
10332         res = test_authenticated_decryption(&tdata);
10333         if (res == TEST_SKIPPED)
10334                 return res;
10335         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10336         return TEST_SUCCESS;
10337 }
10338
10339 static int
10340 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10341 {
10342         struct aead_test_data tdata;
10343         int res;
10344
10345         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10346         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10347         tdata.plaintext.data[0] += 1;
10348         res = test_authenticated_decryption(&tdata);
10349         if (res == TEST_SKIPPED)
10350                 return res;
10351         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10352         return TEST_SUCCESS;
10353 }
10354
10355 static int
10356 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10357 {
10358         struct aead_test_data tdata;
10359         int res;
10360
10361         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10362         tdata.ciphertext.data[0] += 1;
10363         res = test_authenticated_decryption(&tdata);
10364         if (res == TEST_SKIPPED)
10365                 return res;
10366         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10367         return TEST_SUCCESS;
10368 }
10369
10370 static int
10371 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10372 {
10373         struct aead_test_data tdata;
10374         int res;
10375
10376         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10377         tdata.aad.len += 1;
10378         res = test_authenticated_decryption(&tdata);
10379         if (res == TEST_SKIPPED)
10380                 return res;
10381         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10382         return TEST_SUCCESS;
10383 }
10384
10385 static int
10386 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10387 {
10388         struct aead_test_data tdata;
10389         uint8_t aad[gcm_test_case_7.aad.len];
10390         int res;
10391
10392         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10393         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10394         aad[0] += 1;
10395         tdata.aad.data = aad;
10396         res = test_authenticated_decryption(&tdata);
10397         if (res == TEST_SKIPPED)
10398                 return res;
10399         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10400         return TEST_SUCCESS;
10401 }
10402
10403 static int
10404 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10405 {
10406         struct aead_test_data tdata;
10407         int res;
10408
10409         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10410         tdata.auth_tag.data[0] += 1;
10411         res = test_authenticated_decryption(&tdata);
10412         if (res == TEST_SKIPPED)
10413                 return res;
10414         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10415         return TEST_SUCCESS;
10416 }
10417
10418 static int
10419 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10420 {
10421         struct crypto_testsuite_params *ts_params = &testsuite_params;
10422         struct crypto_unittest_params *ut_params = &unittest_params;
10423
10424         int retval;
10425         uint8_t *ciphertext, *auth_tag;
10426         uint16_t plaintext_pad_len;
10427
10428         /* Verify the capabilities */
10429         struct rte_cryptodev_sym_capability_idx cap_idx;
10430         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10431         cap_idx.algo.aead = tdata->algo;
10432         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10433                         &cap_idx) == NULL)
10434                 return TEST_SKIPPED;
10435
10436         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10437                 return TEST_SKIPPED;
10438
10439         /* not supported with CPU crypto */
10440         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10441                 return TEST_SKIPPED;
10442
10443         /* Create AEAD session */
10444         retval = create_aead_session(ts_params->valid_devs[0],
10445                         tdata->algo,
10446                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10447                         tdata->key.data, tdata->key.len,
10448                         tdata->aad.len, tdata->auth_tag.len,
10449                         tdata->iv.len);
10450         if (retval < 0)
10451                 return retval;
10452
10453         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10454         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10455
10456         /* clear mbuf payload */
10457         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10458                         rte_pktmbuf_tailroom(ut_params->ibuf));
10459         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10460                         rte_pktmbuf_tailroom(ut_params->obuf));
10461
10462         /* Create AEAD operation */
10463         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10464         if (retval < 0)
10465                 return retval;
10466
10467         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10468
10469         ut_params->op->sym->m_src = ut_params->ibuf;
10470         ut_params->op->sym->m_dst = ut_params->obuf;
10471
10472         /* Process crypto operation */
10473         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10474                         ut_params->op), "failed to process sym crypto op");
10475
10476         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10477                         "crypto op processing failed");
10478
10479         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10480
10481         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10482                         ut_params->op->sym->cipher.data.offset);
10483         auth_tag = ciphertext + plaintext_pad_len;
10484
10485         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10486         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10487
10488         /* Validate obuf */
10489         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10490                         ciphertext,
10491                         tdata->ciphertext.data,
10492                         tdata->ciphertext.len,
10493                         "Ciphertext data not as expected");
10494
10495         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10496                         auth_tag,
10497                         tdata->auth_tag.data,
10498                         tdata->auth_tag.len,
10499                         "Generated auth tag not as expected");
10500
10501         return 0;
10502
10503 }
10504
10505 static int
10506 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10507 {
10508         return test_authenticated_encryption_oop(&gcm_test_case_5);
10509 }
10510
10511 static int
10512 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10513 {
10514         struct crypto_testsuite_params *ts_params = &testsuite_params;
10515         struct crypto_unittest_params *ut_params = &unittest_params;
10516
10517         int retval;
10518         uint8_t *plaintext;
10519
10520         /* Verify the capabilities */
10521         struct rte_cryptodev_sym_capability_idx cap_idx;
10522         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10523         cap_idx.algo.aead = tdata->algo;
10524         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10525                         &cap_idx) == NULL)
10526                 return TEST_SKIPPED;
10527
10528         /* not supported with CPU crypto and raw data-path APIs*/
10529         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10530                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10531                 return TEST_SKIPPED;
10532
10533         /* Create AEAD session */
10534         retval = create_aead_session(ts_params->valid_devs[0],
10535                         tdata->algo,
10536                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10537                         tdata->key.data, tdata->key.len,
10538                         tdata->aad.len, tdata->auth_tag.len,
10539                         tdata->iv.len);
10540         if (retval < 0)
10541                 return retval;
10542
10543         /* alloc mbuf and set payload */
10544         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10545         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10546
10547         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10548                         rte_pktmbuf_tailroom(ut_params->ibuf));
10549         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10550                         rte_pktmbuf_tailroom(ut_params->obuf));
10551
10552         /* Create AEAD operation */
10553         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10554         if (retval < 0)
10555                 return retval;
10556
10557         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10558
10559         ut_params->op->sym->m_src = ut_params->ibuf;
10560         ut_params->op->sym->m_dst = ut_params->obuf;
10561
10562         /* Process crypto operation */
10563         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10564                         ut_params->op), "failed to process sym crypto op");
10565
10566         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10567                         "crypto op processing failed");
10568
10569         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10570                         ut_params->op->sym->cipher.data.offset);
10571
10572         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10573
10574         /* Validate obuf */
10575         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10576                         plaintext,
10577                         tdata->plaintext.data,
10578                         tdata->plaintext.len,
10579                         "Plaintext data not as expected");
10580
10581         TEST_ASSERT_EQUAL(ut_params->op->status,
10582                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10583                         "Authentication failed");
10584         return 0;
10585 }
10586
10587 static int
10588 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10589 {
10590         return test_authenticated_decryption_oop(&gcm_test_case_5);
10591 }
10592
10593 static int
10594 test_authenticated_encryption_sessionless(
10595                 const struct aead_test_data *tdata)
10596 {
10597         struct crypto_testsuite_params *ts_params = &testsuite_params;
10598         struct crypto_unittest_params *ut_params = &unittest_params;
10599
10600         int retval;
10601         uint8_t *ciphertext, *auth_tag;
10602         uint16_t plaintext_pad_len;
10603         uint8_t key[tdata->key.len + 1];
10604         struct rte_cryptodev_info dev_info;
10605
10606         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10607         uint64_t feat_flags = dev_info.feature_flags;
10608
10609         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10610                 printf("Device doesn't support Sessionless ops.\n");
10611                 return TEST_SKIPPED;
10612         }
10613
10614         /* not supported with CPU crypto */
10615         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10616                 return TEST_SKIPPED;
10617
10618         /* Verify the capabilities */
10619         struct rte_cryptodev_sym_capability_idx cap_idx;
10620         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10621         cap_idx.algo.aead = tdata->algo;
10622         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10623                         &cap_idx) == NULL)
10624                 return TEST_SKIPPED;
10625
10626         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10627
10628         /* clear mbuf payload */
10629         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10630                         rte_pktmbuf_tailroom(ut_params->ibuf));
10631
10632         /* Create AEAD operation */
10633         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10634         if (retval < 0)
10635                 return retval;
10636
10637         /* Create GCM xform */
10638         memcpy(key, tdata->key.data, tdata->key.len);
10639         retval = create_aead_xform(ut_params->op,
10640                         tdata->algo,
10641                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10642                         key, tdata->key.len,
10643                         tdata->aad.len, tdata->auth_tag.len,
10644                         tdata->iv.len);
10645         if (retval < 0)
10646                 return retval;
10647
10648         ut_params->op->sym->m_src = ut_params->ibuf;
10649
10650         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10651                         RTE_CRYPTO_OP_SESSIONLESS,
10652                         "crypto op session type not sessionless");
10653
10654         /* Process crypto operation */
10655         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10656                         ut_params->op), "failed to process sym crypto op");
10657
10658         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10659
10660         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10661                         "crypto op status not success");
10662
10663         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10664
10665         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10666                         ut_params->op->sym->cipher.data.offset);
10667         auth_tag = ciphertext + plaintext_pad_len;
10668
10669         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10670         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10671
10672         /* Validate obuf */
10673         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10674                         ciphertext,
10675                         tdata->ciphertext.data,
10676                         tdata->ciphertext.len,
10677                         "Ciphertext data not as expected");
10678
10679         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10680                         auth_tag,
10681                         tdata->auth_tag.data,
10682                         tdata->auth_tag.len,
10683                         "Generated auth tag not as expected");
10684
10685         return 0;
10686
10687 }
10688
10689 static int
10690 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10691 {
10692         return test_authenticated_encryption_sessionless(
10693                         &gcm_test_case_5);
10694 }
10695
10696 static int
10697 test_authenticated_decryption_sessionless(
10698                 const struct aead_test_data *tdata)
10699 {
10700         struct crypto_testsuite_params *ts_params = &testsuite_params;
10701         struct crypto_unittest_params *ut_params = &unittest_params;
10702
10703         int retval;
10704         uint8_t *plaintext;
10705         uint8_t key[tdata->key.len + 1];
10706         struct rte_cryptodev_info dev_info;
10707
10708         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10709         uint64_t feat_flags = dev_info.feature_flags;
10710
10711         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10712                 printf("Device doesn't support Sessionless ops.\n");
10713                 return TEST_SKIPPED;
10714         }
10715
10716         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10717                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10718                 printf("Device doesn't support RAW data-path APIs.\n");
10719                 return TEST_SKIPPED;
10720         }
10721
10722         /* not supported with CPU crypto */
10723         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10724                 return TEST_SKIPPED;
10725
10726         /* Verify the capabilities */
10727         struct rte_cryptodev_sym_capability_idx cap_idx;
10728         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10729         cap_idx.algo.aead = tdata->algo;
10730         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10731                         &cap_idx) == NULL)
10732                 return TEST_SKIPPED;
10733
10734         /* alloc mbuf and set payload */
10735         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10736
10737         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10738                         rte_pktmbuf_tailroom(ut_params->ibuf));
10739
10740         /* Create AEAD operation */
10741         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10742         if (retval < 0)
10743                 return retval;
10744
10745         /* Create AEAD xform */
10746         memcpy(key, tdata->key.data, tdata->key.len);
10747         retval = create_aead_xform(ut_params->op,
10748                         tdata->algo,
10749                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10750                         key, tdata->key.len,
10751                         tdata->aad.len, tdata->auth_tag.len,
10752                         tdata->iv.len);
10753         if (retval < 0)
10754                 return retval;
10755
10756         ut_params->op->sym->m_src = ut_params->ibuf;
10757
10758         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10759                         RTE_CRYPTO_OP_SESSIONLESS,
10760                         "crypto op session type not sessionless");
10761
10762         /* Process crypto operation */
10763         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10764                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10765                                 ut_params->op, 0, 0, 0, 0);
10766         else
10767                 TEST_ASSERT_NOT_NULL(process_crypto_request(
10768                         ts_params->valid_devs[0], ut_params->op),
10769                                 "failed to process sym crypto op");
10770
10771         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10772
10773         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10774                         "crypto op status not success");
10775
10776         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10777                         ut_params->op->sym->cipher.data.offset);
10778
10779         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10780
10781         /* Validate obuf */
10782         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10783                         plaintext,
10784                         tdata->plaintext.data,
10785                         tdata->plaintext.len,
10786                         "Plaintext data not as expected");
10787
10788         TEST_ASSERT_EQUAL(ut_params->op->status,
10789                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10790                         "Authentication failed");
10791         return 0;
10792 }
10793
10794 static int
10795 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
10796 {
10797         return test_authenticated_decryption_sessionless(
10798                         &gcm_test_case_5);
10799 }
10800
10801 static int
10802 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
10803 {
10804         return test_authenticated_encryption(&ccm_test_case_128_1);
10805 }
10806
10807 static int
10808 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
10809 {
10810         return test_authenticated_encryption(&ccm_test_case_128_2);
10811 }
10812
10813 static int
10814 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
10815 {
10816         return test_authenticated_encryption(&ccm_test_case_128_3);
10817 }
10818
10819 static int
10820 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
10821 {
10822         return test_authenticated_decryption(&ccm_test_case_128_1);
10823 }
10824
10825 static int
10826 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
10827 {
10828         return test_authenticated_decryption(&ccm_test_case_128_2);
10829 }
10830
10831 static int
10832 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
10833 {
10834         return test_authenticated_decryption(&ccm_test_case_128_3);
10835 }
10836
10837 static int
10838 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
10839 {
10840         return test_authenticated_encryption(&ccm_test_case_192_1);
10841 }
10842
10843 static int
10844 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
10845 {
10846         return test_authenticated_encryption(&ccm_test_case_192_2);
10847 }
10848
10849 static int
10850 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10851 {
10852         return test_authenticated_encryption(&ccm_test_case_192_3);
10853 }
10854
10855 static int
10856 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10857 {
10858         return test_authenticated_decryption(&ccm_test_case_192_1);
10859 }
10860
10861 static int
10862 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10863 {
10864         return test_authenticated_decryption(&ccm_test_case_192_2);
10865 }
10866
10867 static int
10868 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10869 {
10870         return test_authenticated_decryption(&ccm_test_case_192_3);
10871 }
10872
10873 static int
10874 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10875 {
10876         return test_authenticated_encryption(&ccm_test_case_256_1);
10877 }
10878
10879 static int
10880 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10881 {
10882         return test_authenticated_encryption(&ccm_test_case_256_2);
10883 }
10884
10885 static int
10886 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10887 {
10888         return test_authenticated_encryption(&ccm_test_case_256_3);
10889 }
10890
10891 static int
10892 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10893 {
10894         return test_authenticated_decryption(&ccm_test_case_256_1);
10895 }
10896
10897 static int
10898 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10899 {
10900         return test_authenticated_decryption(&ccm_test_case_256_2);
10901 }
10902
10903 static int
10904 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10905 {
10906         return test_authenticated_decryption(&ccm_test_case_256_3);
10907 }
10908
10909 static int
10910 test_stats(void)
10911 {
10912         struct crypto_testsuite_params *ts_params = &testsuite_params;
10913         struct rte_cryptodev_stats stats;
10914
10915         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10916                 return TEST_SKIPPED;
10917
10918         /* Verify the capabilities */
10919         struct rte_cryptodev_sym_capability_idx cap_idx;
10920         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10921         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10922         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10923                         &cap_idx) == NULL)
10924                 return TEST_SKIPPED;
10925         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10926         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10927         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10928                         &cap_idx) == NULL)
10929                 return TEST_SKIPPED;
10930
10931         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10932                         == -ENOTSUP)
10933                 return TEST_SKIPPED;
10934
10935         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10936         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10937                         &stats) == -ENODEV),
10938                 "rte_cryptodev_stats_get invalid dev failed");
10939         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10940                 "rte_cryptodev_stats_get invalid Param failed");
10941
10942         /* Test expected values */
10943         test_AES_CBC_HMAC_SHA1_encrypt_digest();
10944         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10945                         &stats),
10946                 "rte_cryptodev_stats_get failed");
10947         TEST_ASSERT((stats.enqueued_count == 1),
10948                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10949         TEST_ASSERT((stats.dequeued_count == 1),
10950                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10951         TEST_ASSERT((stats.enqueue_err_count == 0),
10952                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10953         TEST_ASSERT((stats.dequeue_err_count == 0),
10954                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10955
10956         /* invalid device but should ignore and not reset device stats*/
10957         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10958         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10959                         &stats),
10960                 "rte_cryptodev_stats_get failed");
10961         TEST_ASSERT((stats.enqueued_count == 1),
10962                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10963
10964         /* check that a valid reset clears stats */
10965         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10966         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10967                         &stats),
10968                                           "rte_cryptodev_stats_get failed");
10969         TEST_ASSERT((stats.enqueued_count == 0),
10970                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10971         TEST_ASSERT((stats.dequeued_count == 0),
10972                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10973
10974         return TEST_SUCCESS;
10975 }
10976
10977 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10978                                    struct crypto_unittest_params *ut_params,
10979                                    enum rte_crypto_auth_operation op,
10980                                    const struct HMAC_MD5_vector *test_case)
10981 {
10982         uint8_t key[64];
10983
10984         memcpy(key, test_case->key.data, test_case->key.len);
10985
10986         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10987         ut_params->auth_xform.next = NULL;
10988         ut_params->auth_xform.auth.op = op;
10989
10990         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10991
10992         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10993         ut_params->auth_xform.auth.key.length = test_case->key.len;
10994         ut_params->auth_xform.auth.key.data = key;
10995
10996         ut_params->sess = rte_cryptodev_sym_session_create(
10997                         ts_params->session_mpool);
10998
10999         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11000                         ut_params->sess, &ut_params->auth_xform,
11001                         ts_params->session_priv_mpool);
11002
11003         if (ut_params->sess == NULL)
11004                 return TEST_FAILED;
11005
11006         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11007
11008         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11009                         rte_pktmbuf_tailroom(ut_params->ibuf));
11010
11011         return 0;
11012 }
11013
11014 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11015                               const struct HMAC_MD5_vector *test_case,
11016                               uint8_t **plaintext)
11017 {
11018         uint16_t plaintext_pad_len;
11019
11020         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11021
11022         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11023                                 16);
11024
11025         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11026                         plaintext_pad_len);
11027         memcpy(*plaintext, test_case->plaintext.data,
11028                         test_case->plaintext.len);
11029
11030         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11031                         ut_params->ibuf, MD5_DIGEST_LEN);
11032         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11033                         "no room to append digest");
11034         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11035                         ut_params->ibuf, plaintext_pad_len);
11036
11037         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11038                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11039                            test_case->auth_tag.len);
11040         }
11041
11042         sym_op->auth.data.offset = 0;
11043         sym_op->auth.data.length = test_case->plaintext.len;
11044
11045         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11046         ut_params->op->sym->m_src = ut_params->ibuf;
11047
11048         return 0;
11049 }
11050
11051 static int
11052 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11053 {
11054         uint16_t plaintext_pad_len;
11055         uint8_t *plaintext, *auth_tag;
11056
11057         struct crypto_testsuite_params *ts_params = &testsuite_params;
11058         struct crypto_unittest_params *ut_params = &unittest_params;
11059         struct rte_cryptodev_info dev_info;
11060
11061         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11062         uint64_t feat_flags = dev_info.feature_flags;
11063
11064         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11065                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11066                 printf("Device doesn't support RAW data-path APIs.\n");
11067                 return TEST_SKIPPED;
11068         }
11069
11070         /* Verify the capabilities */
11071         struct rte_cryptodev_sym_capability_idx cap_idx;
11072         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11073         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11074         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11075                         &cap_idx) == NULL)
11076                 return TEST_SKIPPED;
11077
11078         if (MD5_HMAC_create_session(ts_params, ut_params,
11079                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11080                 return TEST_FAILED;
11081
11082         /* Generate Crypto op data structure */
11083         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11084                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11085         TEST_ASSERT_NOT_NULL(ut_params->op,
11086                         "Failed to allocate symmetric crypto operation struct");
11087
11088         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11089                                 16);
11090
11091         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11092                 return TEST_FAILED;
11093
11094         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11095                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11096                         ut_params->op);
11097         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11098                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11099                                 ut_params->op, 0, 1, 0, 0);
11100         else
11101                 TEST_ASSERT_NOT_NULL(
11102                         process_crypto_request(ts_params->valid_devs[0],
11103                                 ut_params->op),
11104                                 "failed to process sym crypto op");
11105
11106         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11107                         "crypto op processing failed");
11108
11109         if (ut_params->op->sym->m_dst) {
11110                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11111                                 uint8_t *, plaintext_pad_len);
11112         } else {
11113                 auth_tag = plaintext + plaintext_pad_len;
11114         }
11115
11116         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11117                         auth_tag,
11118                         test_case->auth_tag.data,
11119                         test_case->auth_tag.len,
11120                         "HMAC_MD5 generated tag not as expected");
11121
11122         return TEST_SUCCESS;
11123 }
11124
11125 static int
11126 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11127 {
11128         uint8_t *plaintext;
11129
11130         struct crypto_testsuite_params *ts_params = &testsuite_params;
11131         struct crypto_unittest_params *ut_params = &unittest_params;
11132         struct rte_cryptodev_info dev_info;
11133
11134         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11135         uint64_t feat_flags = dev_info.feature_flags;
11136
11137         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11138                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11139                 printf("Device doesn't support RAW data-path APIs.\n");
11140                 return TEST_SKIPPED;
11141         }
11142
11143         /* Verify the capabilities */
11144         struct rte_cryptodev_sym_capability_idx cap_idx;
11145         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11146         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11147         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11148                         &cap_idx) == NULL)
11149                 return TEST_SKIPPED;
11150
11151         if (MD5_HMAC_create_session(ts_params, ut_params,
11152                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11153                 return TEST_FAILED;
11154         }
11155
11156         /* Generate Crypto op data structure */
11157         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11158                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11159         TEST_ASSERT_NOT_NULL(ut_params->op,
11160                         "Failed to allocate symmetric crypto operation struct");
11161
11162         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11163                 return TEST_FAILED;
11164
11165         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11166                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11167                         ut_params->op);
11168         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11169                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11170                                 ut_params->op, 0, 1, 0, 0);
11171         else
11172                 TEST_ASSERT_NOT_NULL(
11173                         process_crypto_request(ts_params->valid_devs[0],
11174                                 ut_params->op),
11175                                 "failed to process sym crypto op");
11176
11177         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11178                         "HMAC_MD5 crypto op processing failed");
11179
11180         return TEST_SUCCESS;
11181 }
11182
11183 static int
11184 test_MD5_HMAC_generate_case_1(void)
11185 {
11186         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11187 }
11188
11189 static int
11190 test_MD5_HMAC_verify_case_1(void)
11191 {
11192         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11193 }
11194
11195 static int
11196 test_MD5_HMAC_generate_case_2(void)
11197 {
11198         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11199 }
11200
11201 static int
11202 test_MD5_HMAC_verify_case_2(void)
11203 {
11204         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11205 }
11206
11207 static int
11208 test_multi_session(void)
11209 {
11210         struct crypto_testsuite_params *ts_params = &testsuite_params;
11211         struct crypto_unittest_params *ut_params = &unittest_params;
11212
11213         struct rte_cryptodev_info dev_info;
11214         struct rte_cryptodev_sym_session **sessions;
11215
11216         uint16_t i;
11217
11218         /* Verify the capabilities */
11219         struct rte_cryptodev_sym_capability_idx cap_idx;
11220         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11221         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11222         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11223                         &cap_idx) == NULL)
11224                 return TEST_SKIPPED;
11225         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11226         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11227         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11228                         &cap_idx) == NULL)
11229                 return TEST_SKIPPED;
11230
11231         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11232                         aes_cbc_key, hmac_sha512_key);
11233
11234
11235         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11236
11237         sessions = rte_malloc(NULL,
11238                         sizeof(struct rte_cryptodev_sym_session *) *
11239                         (MAX_NB_SESSIONS + 1), 0);
11240
11241         /* Create multiple crypto sessions*/
11242         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11243
11244                 sessions[i] = rte_cryptodev_sym_session_create(
11245                                 ts_params->session_mpool);
11246
11247                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11248                                 sessions[i], &ut_params->auth_xform,
11249                                 ts_params->session_priv_mpool);
11250                 TEST_ASSERT_NOT_NULL(sessions[i],
11251                                 "Session creation failed at session number %u",
11252                                 i);
11253
11254                 /* Attempt to send a request on each session */
11255                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11256                         sessions[i],
11257                         ut_params,
11258                         ts_params,
11259                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11260                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11261                         aes_cbc_iv),
11262                         "Failed to perform decrypt on request number %u.", i);
11263                 /* free crypto operation structure */
11264                 if (ut_params->op)
11265                         rte_crypto_op_free(ut_params->op);
11266
11267                 /*
11268                  * free mbuf - both obuf and ibuf are usually the same,
11269                  * so check if they point at the same address is necessary,
11270                  * to avoid freeing the mbuf twice.
11271                  */
11272                 if (ut_params->obuf) {
11273                         rte_pktmbuf_free(ut_params->obuf);
11274                         if (ut_params->ibuf == ut_params->obuf)
11275                                 ut_params->ibuf = 0;
11276                         ut_params->obuf = 0;
11277                 }
11278                 if (ut_params->ibuf) {
11279                         rte_pktmbuf_free(ut_params->ibuf);
11280                         ut_params->ibuf = 0;
11281                 }
11282         }
11283
11284         sessions[i] = NULL;
11285         /* Next session create should fail */
11286         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11287                         sessions[i], &ut_params->auth_xform,
11288                         ts_params->session_priv_mpool);
11289         TEST_ASSERT_NULL(sessions[i],
11290                         "Session creation succeeded unexpectedly!");
11291
11292         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11293                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11294                                 sessions[i]);
11295                 rte_cryptodev_sym_session_free(sessions[i]);
11296         }
11297
11298         rte_free(sessions);
11299
11300         return TEST_SUCCESS;
11301 }
11302
11303 struct multi_session_params {
11304         struct crypto_unittest_params ut_params;
11305         uint8_t *cipher_key;
11306         uint8_t *hmac_key;
11307         const uint8_t *cipher;
11308         const uint8_t *digest;
11309         uint8_t *iv;
11310 };
11311
11312 #define MB_SESSION_NUMBER 3
11313
11314 static int
11315 test_multi_session_random_usage(void)
11316 {
11317         struct crypto_testsuite_params *ts_params = &testsuite_params;
11318         struct rte_cryptodev_info dev_info;
11319         struct rte_cryptodev_sym_session **sessions;
11320         uint32_t i, j;
11321         struct multi_session_params ut_paramz[] = {
11322
11323                 {
11324                         .cipher_key = ms_aes_cbc_key0,
11325                         .hmac_key = ms_hmac_key0,
11326                         .cipher = ms_aes_cbc_cipher0,
11327                         .digest = ms_hmac_digest0,
11328                         .iv = ms_aes_cbc_iv0
11329                 },
11330                 {
11331                         .cipher_key = ms_aes_cbc_key1,
11332                         .hmac_key = ms_hmac_key1,
11333                         .cipher = ms_aes_cbc_cipher1,
11334                         .digest = ms_hmac_digest1,
11335                         .iv = ms_aes_cbc_iv1
11336                 },
11337                 {
11338                         .cipher_key = ms_aes_cbc_key2,
11339                         .hmac_key = ms_hmac_key2,
11340                         .cipher = ms_aes_cbc_cipher2,
11341                         .digest = ms_hmac_digest2,
11342                         .iv = ms_aes_cbc_iv2
11343                 },
11344
11345         };
11346
11347         /* Verify the capabilities */
11348         struct rte_cryptodev_sym_capability_idx cap_idx;
11349         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11350         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11351         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11352                         &cap_idx) == NULL)
11353                 return TEST_SKIPPED;
11354         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11355         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11356         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11357                         &cap_idx) == NULL)
11358                 return TEST_SKIPPED;
11359
11360         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11361
11362         sessions = rte_malloc(NULL,
11363                         (sizeof(struct rte_cryptodev_sym_session *)
11364                                         * MAX_NB_SESSIONS) + 1, 0);
11365
11366         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11367                 sessions[i] = rte_cryptodev_sym_session_create(
11368                                 ts_params->session_mpool);
11369
11370                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11371                                 sizeof(struct crypto_unittest_params));
11372
11373                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11374                                 &ut_paramz[i].ut_params,
11375                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11376
11377                 /* Create multiple crypto sessions*/
11378                 rte_cryptodev_sym_session_init(
11379                                 ts_params->valid_devs[0],
11380                                 sessions[i],
11381                                 &ut_paramz[i].ut_params.auth_xform,
11382                                 ts_params->session_priv_mpool);
11383
11384                 TEST_ASSERT_NOT_NULL(sessions[i],
11385                                 "Session creation failed at session number %u",
11386                                 i);
11387
11388         }
11389
11390         srand(time(NULL));
11391         for (i = 0; i < 40000; i++) {
11392
11393                 j = rand() % MB_SESSION_NUMBER;
11394
11395                 TEST_ASSERT_SUCCESS(
11396                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11397                                         sessions[j],
11398                                         &ut_paramz[j].ut_params,
11399                                         ts_params, ut_paramz[j].cipher,
11400                                         ut_paramz[j].digest,
11401                                         ut_paramz[j].iv),
11402                         "Failed to perform decrypt on request number %u.", i);
11403
11404                 if (ut_paramz[j].ut_params.op)
11405                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11406
11407                 /*
11408                  * free mbuf - both obuf and ibuf are usually the same,
11409                  * so check if they point at the same address is necessary,
11410                  * to avoid freeing the mbuf twice.
11411                  */
11412                 if (ut_paramz[j].ut_params.obuf) {
11413                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11414                         if (ut_paramz[j].ut_params.ibuf
11415                                         == ut_paramz[j].ut_params.obuf)
11416                                 ut_paramz[j].ut_params.ibuf = 0;
11417                         ut_paramz[j].ut_params.obuf = 0;
11418                 }
11419                 if (ut_paramz[j].ut_params.ibuf) {
11420                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11421                         ut_paramz[j].ut_params.ibuf = 0;
11422                 }
11423         }
11424
11425         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11426                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11427                                 sessions[i]);
11428                 rte_cryptodev_sym_session_free(sessions[i]);
11429         }
11430
11431         rte_free(sessions);
11432
11433         return TEST_SUCCESS;
11434 }
11435
11436 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11437                         0xab, 0xab, 0xab, 0xab,
11438                         0xab, 0xab, 0xab, 0xab,
11439                         0xab, 0xab, 0xab, 0xab};
11440
11441 static int
11442 test_null_invalid_operation(void)
11443 {
11444         struct crypto_testsuite_params *ts_params = &testsuite_params;
11445         struct crypto_unittest_params *ut_params = &unittest_params;
11446         int ret;
11447
11448         /* This test is for NULL PMD only */
11449         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11450                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11451                 return TEST_SKIPPED;
11452
11453         /* Setup Cipher Parameters */
11454         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11455         ut_params->cipher_xform.next = NULL;
11456
11457         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11458         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11459
11460         ut_params->sess = rte_cryptodev_sym_session_create(
11461                         ts_params->session_mpool);
11462
11463         /* Create Crypto session*/
11464         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11465                         ut_params->sess, &ut_params->cipher_xform,
11466                         ts_params->session_priv_mpool);
11467         TEST_ASSERT(ret < 0,
11468                         "Session creation succeeded unexpectedly");
11469
11470
11471         /* Setup HMAC Parameters */
11472         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11473         ut_params->auth_xform.next = NULL;
11474
11475         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11476         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11477
11478         ut_params->sess = rte_cryptodev_sym_session_create(
11479                         ts_params->session_mpool);
11480
11481         /* Create Crypto session*/
11482         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11483                         ut_params->sess, &ut_params->auth_xform,
11484                         ts_params->session_priv_mpool);
11485         TEST_ASSERT(ret < 0,
11486                         "Session creation succeeded unexpectedly");
11487
11488         return TEST_SUCCESS;
11489 }
11490
11491
11492 #define NULL_BURST_LENGTH (32)
11493
11494 static int
11495 test_null_burst_operation(void)
11496 {
11497         struct crypto_testsuite_params *ts_params = &testsuite_params;
11498         struct crypto_unittest_params *ut_params = &unittest_params;
11499
11500         unsigned i, burst_len = NULL_BURST_LENGTH;
11501
11502         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11503         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11504
11505         /* This test is for NULL PMD only */
11506         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11507                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11508                 return TEST_SKIPPED;
11509
11510         /* Setup Cipher Parameters */
11511         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11512         ut_params->cipher_xform.next = &ut_params->auth_xform;
11513
11514         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11515         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11516
11517         /* Setup HMAC Parameters */
11518         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11519         ut_params->auth_xform.next = NULL;
11520
11521         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11522         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11523
11524         ut_params->sess = rte_cryptodev_sym_session_create(
11525                         ts_params->session_mpool);
11526
11527         /* Create Crypto session*/
11528         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11529                         ut_params->sess, &ut_params->cipher_xform,
11530                         ts_params->session_priv_mpool);
11531         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11532
11533         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11534                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11535                         burst_len, "failed to generate burst of crypto ops");
11536
11537         /* Generate an operation for each mbuf in burst */
11538         for (i = 0; i < burst_len; i++) {
11539                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11540
11541                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11542
11543                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11544                                 sizeof(unsigned));
11545                 *data = i;
11546
11547                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11548
11549                 burst[i]->sym->m_src = m;
11550         }
11551
11552         /* Process crypto operation */
11553         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11554                         0, burst, burst_len),
11555                         burst_len,
11556                         "Error enqueuing burst");
11557
11558         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11559                         0, burst_dequeued, burst_len),
11560                         burst_len,
11561                         "Error dequeuing burst");
11562
11563
11564         for (i = 0; i < burst_len; i++) {
11565                 TEST_ASSERT_EQUAL(
11566                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11567                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11568                                         uint32_t *),
11569                         "data not as expected");
11570
11571                 rte_pktmbuf_free(burst[i]->sym->m_src);
11572                 rte_crypto_op_free(burst[i]);
11573         }
11574
11575         return TEST_SUCCESS;
11576 }
11577
11578 static uint16_t
11579 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11580                   uint16_t nb_ops, void *user_param)
11581 {
11582         RTE_SET_USED(dev_id);
11583         RTE_SET_USED(qp_id);
11584         RTE_SET_USED(ops);
11585         RTE_SET_USED(user_param);
11586
11587         printf("crypto enqueue callback called\n");
11588         return nb_ops;
11589 }
11590
11591 static uint16_t
11592 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11593                   uint16_t nb_ops, void *user_param)
11594 {
11595         RTE_SET_USED(dev_id);
11596         RTE_SET_USED(qp_id);
11597         RTE_SET_USED(ops);
11598         RTE_SET_USED(user_param);
11599
11600         printf("crypto dequeue callback called\n");
11601         return nb_ops;
11602 }
11603
11604 /*
11605  * Thread using enqueue/dequeue callback with RCU.
11606  */
11607 static int
11608 test_enqdeq_callback_thread(void *arg)
11609 {
11610         RTE_SET_USED(arg);
11611         /* DP thread calls rte_cryptodev_enqueue_burst()/
11612          * rte_cryptodev_dequeue_burst() and invokes callback.
11613          */
11614         test_null_burst_operation();
11615         return 0;
11616 }
11617
11618 static int
11619 test_enq_callback_setup(void)
11620 {
11621         struct crypto_testsuite_params *ts_params = &testsuite_params;
11622         struct rte_cryptodev_info dev_info;
11623         struct rte_cryptodev_qp_conf qp_conf = {
11624                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11625         };
11626
11627         struct rte_cryptodev_cb *cb;
11628         uint16_t qp_id = 0;
11629
11630         /* Stop the device in case it's started so it can be configured */
11631         rte_cryptodev_stop(ts_params->valid_devs[0]);
11632
11633         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11634
11635         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11636                         &ts_params->conf),
11637                         "Failed to configure cryptodev %u",
11638                         ts_params->valid_devs[0]);
11639
11640         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11641         qp_conf.mp_session = ts_params->session_mpool;
11642         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11643
11644         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11645                         ts_params->valid_devs[0], qp_id, &qp_conf,
11646                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11647                         "Failed test for "
11648                         "rte_cryptodev_queue_pair_setup: num_inflights "
11649                         "%u on qp %u on cryptodev %u",
11650                         qp_conf.nb_descriptors, qp_id,
11651                         ts_params->valid_devs[0]);
11652
11653         /* Test with invalid crypto device */
11654         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11655                         qp_id, test_enq_callback, NULL);
11656         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11657                         "cryptodev %u did not fail",
11658                         qp_id, RTE_CRYPTO_MAX_DEVS);
11659
11660         /* Test with invalid queue pair */
11661         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11662                         dev_info.max_nb_queue_pairs + 1,
11663                         test_enq_callback, NULL);
11664         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11665                         "cryptodev %u did not fail",
11666                         dev_info.max_nb_queue_pairs + 1,
11667                         ts_params->valid_devs[0]);
11668
11669         /* Test with NULL callback */
11670         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11671                         qp_id, NULL, NULL);
11672         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11673                         "cryptodev %u did not fail",
11674                         qp_id, ts_params->valid_devs[0]);
11675
11676         /* Test with valid configuration */
11677         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11678                         qp_id, test_enq_callback, NULL);
11679         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11680                         "qp %u on cryptodev %u",
11681                         qp_id, ts_params->valid_devs[0]);
11682
11683         rte_cryptodev_start(ts_params->valid_devs[0]);
11684
11685         /* Launch a thread */
11686         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11687                                 rte_get_next_lcore(-1, 1, 0));
11688
11689         /* Wait until reader exited. */
11690         rte_eal_mp_wait_lcore();
11691
11692         /* Test with invalid crypto device */
11693         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11694                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11695                         "Expected call to fail as crypto device is invalid");
11696
11697         /* Test with invalid queue pair */
11698         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11699                         ts_params->valid_devs[0],
11700                         dev_info.max_nb_queue_pairs + 1, cb),
11701                         "Expected call to fail as queue pair is invalid");
11702
11703         /* Test with NULL callback */
11704         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11705                         ts_params->valid_devs[0], qp_id, NULL),
11706                         "Expected call to fail as callback is NULL");
11707
11708         /* Test with valid configuration */
11709         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11710                         ts_params->valid_devs[0], qp_id, cb),
11711                         "Failed test to remove callback on "
11712                         "qp %u on cryptodev %u",
11713                         qp_id, ts_params->valid_devs[0]);
11714
11715         return TEST_SUCCESS;
11716 }
11717
11718 static int
11719 test_deq_callback_setup(void)
11720 {
11721         struct crypto_testsuite_params *ts_params = &testsuite_params;
11722         struct rte_cryptodev_info dev_info;
11723         struct rte_cryptodev_qp_conf qp_conf = {
11724                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11725         };
11726
11727         struct rte_cryptodev_cb *cb;
11728         uint16_t qp_id = 0;
11729
11730         /* Stop the device in case it's started so it can be configured */
11731         rte_cryptodev_stop(ts_params->valid_devs[0]);
11732
11733         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11734
11735         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11736                         &ts_params->conf),
11737                         "Failed to configure cryptodev %u",
11738                         ts_params->valid_devs[0]);
11739
11740         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11741         qp_conf.mp_session = ts_params->session_mpool;
11742         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11743
11744         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11745                         ts_params->valid_devs[0], qp_id, &qp_conf,
11746                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11747                         "Failed test for "
11748                         "rte_cryptodev_queue_pair_setup: num_inflights "
11749                         "%u on qp %u on cryptodev %u",
11750                         qp_conf.nb_descriptors, qp_id,
11751                         ts_params->valid_devs[0]);
11752
11753         /* Test with invalid crypto device */
11754         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
11755                         qp_id, test_deq_callback, NULL);
11756         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11757                         "cryptodev %u did not fail",
11758                         qp_id, RTE_CRYPTO_MAX_DEVS);
11759
11760         /* Test with invalid queue pair */
11761         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11762                         dev_info.max_nb_queue_pairs + 1,
11763                         test_deq_callback, NULL);
11764         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11765                         "cryptodev %u did not fail",
11766                         dev_info.max_nb_queue_pairs + 1,
11767                         ts_params->valid_devs[0]);
11768
11769         /* Test with NULL callback */
11770         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11771                         qp_id, NULL, NULL);
11772         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11773                         "cryptodev %u did not fail",
11774                         qp_id, ts_params->valid_devs[0]);
11775
11776         /* Test with valid configuration */
11777         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
11778                         qp_id, test_deq_callback, NULL);
11779         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11780                         "qp %u on cryptodev %u",
11781                         qp_id, ts_params->valid_devs[0]);
11782
11783         rte_cryptodev_start(ts_params->valid_devs[0]);
11784
11785         /* Launch a thread */
11786         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11787                                 rte_get_next_lcore(-1, 1, 0));
11788
11789         /* Wait until reader exited. */
11790         rte_eal_mp_wait_lcore();
11791
11792         /* Test with invalid crypto device */
11793         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11794                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11795                         "Expected call to fail as crypto device is invalid");
11796
11797         /* Test with invalid queue pair */
11798         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11799                         ts_params->valid_devs[0],
11800                         dev_info.max_nb_queue_pairs + 1, cb),
11801                         "Expected call to fail as queue pair is invalid");
11802
11803         /* Test with NULL callback */
11804         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
11805                         ts_params->valid_devs[0], qp_id, NULL),
11806                         "Expected call to fail as callback is NULL");
11807
11808         /* Test with valid configuration */
11809         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
11810                         ts_params->valid_devs[0], qp_id, cb),
11811                         "Failed test to remove callback on "
11812                         "qp %u on cryptodev %u",
11813                         qp_id, ts_params->valid_devs[0]);
11814
11815         return TEST_SUCCESS;
11816 }
11817
11818 static void
11819 generate_gmac_large_plaintext(uint8_t *data)
11820 {
11821         uint16_t i;
11822
11823         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
11824                 memcpy(&data[i], &data[0], 32);
11825 }
11826
11827 static int
11828 create_gmac_operation(enum rte_crypto_auth_operation op,
11829                 const struct gmac_test_data *tdata)
11830 {
11831         struct crypto_testsuite_params *ts_params = &testsuite_params;
11832         struct crypto_unittest_params *ut_params = &unittest_params;
11833         struct rte_crypto_sym_op *sym_op;
11834
11835         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11836
11837         /* Generate Crypto op data structure */
11838         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11839                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11840         TEST_ASSERT_NOT_NULL(ut_params->op,
11841                         "Failed to allocate symmetric crypto operation struct");
11842
11843         sym_op = ut_params->op->sym;
11844
11845         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11846                         ut_params->ibuf, tdata->gmac_tag.len);
11847         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11848                         "no room to append digest");
11849
11850         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11851                         ut_params->ibuf, plaintext_pad_len);
11852
11853         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11854                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11855                                 tdata->gmac_tag.len);
11856                 debug_hexdump(stdout, "digest:",
11857                                 sym_op->auth.digest.data,
11858                                 tdata->gmac_tag.len);
11859         }
11860
11861         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11862                         uint8_t *, IV_OFFSET);
11863
11864         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11865
11866         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11867
11868         sym_op->cipher.data.length = 0;
11869         sym_op->cipher.data.offset = 0;
11870
11871         sym_op->auth.data.offset = 0;
11872         sym_op->auth.data.length = tdata->plaintext.len;
11873
11874         return 0;
11875 }
11876
11877 static int
11878 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
11879                 const struct gmac_test_data *tdata,
11880                 void *digest_mem, uint64_t digest_phys)
11881 {
11882         struct crypto_testsuite_params *ts_params = &testsuite_params;
11883         struct crypto_unittest_params *ut_params = &unittest_params;
11884         struct rte_crypto_sym_op *sym_op;
11885
11886         /* Generate Crypto op data structure */
11887         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11888                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11889         TEST_ASSERT_NOT_NULL(ut_params->op,
11890                         "Failed to allocate symmetric crypto operation struct");
11891
11892         sym_op = ut_params->op->sym;
11893
11894         sym_op->auth.digest.data = digest_mem;
11895         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11896                         "no room to append digest");
11897
11898         sym_op->auth.digest.phys_addr = digest_phys;
11899
11900         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11901                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11902                                 tdata->gmac_tag.len);
11903                 debug_hexdump(stdout, "digest:",
11904                                 sym_op->auth.digest.data,
11905                                 tdata->gmac_tag.len);
11906         }
11907
11908         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11909                         uint8_t *, IV_OFFSET);
11910
11911         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11912
11913         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11914
11915         sym_op->cipher.data.length = 0;
11916         sym_op->cipher.data.offset = 0;
11917
11918         sym_op->auth.data.offset = 0;
11919         sym_op->auth.data.length = tdata->plaintext.len;
11920
11921         return 0;
11922 }
11923
11924 static int create_gmac_session(uint8_t dev_id,
11925                 const struct gmac_test_data *tdata,
11926                 enum rte_crypto_auth_operation auth_op)
11927 {
11928         uint8_t auth_key[tdata->key.len];
11929
11930         struct crypto_testsuite_params *ts_params = &testsuite_params;
11931         struct crypto_unittest_params *ut_params = &unittest_params;
11932
11933         memcpy(auth_key, tdata->key.data, tdata->key.len);
11934
11935         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11936         ut_params->auth_xform.next = NULL;
11937
11938         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
11939         ut_params->auth_xform.auth.op = auth_op;
11940         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
11941         ut_params->auth_xform.auth.key.length = tdata->key.len;
11942         ut_params->auth_xform.auth.key.data = auth_key;
11943         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11944         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
11945
11946
11947         ut_params->sess = rte_cryptodev_sym_session_create(
11948                         ts_params->session_mpool);
11949
11950         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11951                         &ut_params->auth_xform,
11952                         ts_params->session_priv_mpool);
11953
11954         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11955
11956         return 0;
11957 }
11958
11959 static int
11960 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
11961 {
11962         struct crypto_testsuite_params *ts_params = &testsuite_params;
11963         struct crypto_unittest_params *ut_params = &unittest_params;
11964         struct rte_cryptodev_info dev_info;
11965
11966         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11967         uint64_t feat_flags = dev_info.feature_flags;
11968
11969         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11970                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11971                 printf("Device doesn't support RAW data-path APIs.\n");
11972                 return TEST_SKIPPED;
11973         }
11974
11975         int retval;
11976
11977         uint8_t *auth_tag, *plaintext;
11978         uint16_t plaintext_pad_len;
11979
11980         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11981                               "No GMAC length in the source data");
11982
11983         /* Verify the capabilities */
11984         struct rte_cryptodev_sym_capability_idx cap_idx;
11985         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11986         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11987         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11988                         &cap_idx) == NULL)
11989                 return TEST_SKIPPED;
11990
11991         retval = create_gmac_session(ts_params->valid_devs[0],
11992                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11993
11994         if (retval < 0)
11995                 return retval;
11996
11997         if (tdata->plaintext.len > MBUF_SIZE)
11998                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11999         else
12000                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12001         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12002                         "Failed to allocate input buffer in mempool");
12003
12004         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12005                         rte_pktmbuf_tailroom(ut_params->ibuf));
12006
12007         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12008         /*
12009          * Runtime generate the large plain text instead of use hard code
12010          * plain text vector. It is done to avoid create huge source file
12011          * with the test vector.
12012          */
12013         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12014                 generate_gmac_large_plaintext(tdata->plaintext.data);
12015
12016         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12017                                 plaintext_pad_len);
12018         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12019
12020         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12021         debug_hexdump(stdout, "plaintext:", plaintext,
12022                         tdata->plaintext.len);
12023
12024         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12025                         tdata);
12026
12027         if (retval < 0)
12028                 return retval;
12029
12030         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12031
12032         ut_params->op->sym->m_src = ut_params->ibuf;
12033
12034         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12035                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12036                         ut_params->op);
12037         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12038                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12039                                 ut_params->op, 0, 1, 0, 0);
12040         else
12041                 TEST_ASSERT_NOT_NULL(
12042                         process_crypto_request(ts_params->valid_devs[0],
12043                         ut_params->op), "failed to process sym crypto op");
12044
12045         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12046                         "crypto op processing failed");
12047
12048         if (ut_params->op->sym->m_dst) {
12049                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12050                                 uint8_t *, plaintext_pad_len);
12051         } else {
12052                 auth_tag = plaintext + plaintext_pad_len;
12053         }
12054
12055         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12056
12057         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12058                         auth_tag,
12059                         tdata->gmac_tag.data,
12060                         tdata->gmac_tag.len,
12061                         "GMAC Generated auth tag not as expected");
12062
12063         return 0;
12064 }
12065
12066 static int
12067 test_AES_GMAC_authentication_test_case_1(void)
12068 {
12069         return test_AES_GMAC_authentication(&gmac_test_case_1);
12070 }
12071
12072 static int
12073 test_AES_GMAC_authentication_test_case_2(void)
12074 {
12075         return test_AES_GMAC_authentication(&gmac_test_case_2);
12076 }
12077
12078 static int
12079 test_AES_GMAC_authentication_test_case_3(void)
12080 {
12081         return test_AES_GMAC_authentication(&gmac_test_case_3);
12082 }
12083
12084 static int
12085 test_AES_GMAC_authentication_test_case_4(void)
12086 {
12087         return test_AES_GMAC_authentication(&gmac_test_case_4);
12088 }
12089
12090 static int
12091 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12092 {
12093         struct crypto_testsuite_params *ts_params = &testsuite_params;
12094         struct crypto_unittest_params *ut_params = &unittest_params;
12095         int retval;
12096         uint32_t plaintext_pad_len;
12097         uint8_t *plaintext;
12098         struct rte_cryptodev_info dev_info;
12099
12100         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12101         uint64_t feat_flags = dev_info.feature_flags;
12102
12103         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12104                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12105                 printf("Device doesn't support RAW data-path APIs.\n");
12106                 return TEST_SKIPPED;
12107         }
12108
12109         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12110                               "No GMAC length in the source data");
12111
12112         /* Verify the capabilities */
12113         struct rte_cryptodev_sym_capability_idx cap_idx;
12114         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12115         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12116         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12117                         &cap_idx) == NULL)
12118                 return TEST_SKIPPED;
12119
12120         retval = create_gmac_session(ts_params->valid_devs[0],
12121                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12122
12123         if (retval < 0)
12124                 return retval;
12125
12126         if (tdata->plaintext.len > MBUF_SIZE)
12127                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12128         else
12129                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12130         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12131                         "Failed to allocate input buffer in mempool");
12132
12133         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12134                         rte_pktmbuf_tailroom(ut_params->ibuf));
12135
12136         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12137
12138         /*
12139          * Runtime generate the large plain text instead of use hard code
12140          * plain text vector. It is done to avoid create huge source file
12141          * with the test vector.
12142          */
12143         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12144                 generate_gmac_large_plaintext(tdata->plaintext.data);
12145
12146         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12147                                 plaintext_pad_len);
12148         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12149
12150         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12151         debug_hexdump(stdout, "plaintext:", plaintext,
12152                         tdata->plaintext.len);
12153
12154         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12155                         tdata);
12156
12157         if (retval < 0)
12158                 return retval;
12159
12160         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12161
12162         ut_params->op->sym->m_src = ut_params->ibuf;
12163
12164         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12165                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12166                         ut_params->op);
12167         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12168                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12169                                 ut_params->op, 0, 1, 0, 0);
12170         else
12171                 TEST_ASSERT_NOT_NULL(
12172                         process_crypto_request(ts_params->valid_devs[0],
12173                         ut_params->op), "failed to process sym crypto op");
12174
12175         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12176                         "crypto op processing failed");
12177
12178         return 0;
12179
12180 }
12181
12182 static int
12183 test_AES_GMAC_authentication_verify_test_case_1(void)
12184 {
12185         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12186 }
12187
12188 static int
12189 test_AES_GMAC_authentication_verify_test_case_2(void)
12190 {
12191         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12192 }
12193
12194 static int
12195 test_AES_GMAC_authentication_verify_test_case_3(void)
12196 {
12197         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12198 }
12199
12200 static int
12201 test_AES_GMAC_authentication_verify_test_case_4(void)
12202 {
12203         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12204 }
12205
12206 static int
12207 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12208                                 uint32_t fragsz)
12209 {
12210         struct crypto_testsuite_params *ts_params = &testsuite_params;
12211         struct crypto_unittest_params *ut_params = &unittest_params;
12212         struct rte_cryptodev_info dev_info;
12213         uint64_t feature_flags;
12214         unsigned int trn_data = 0;
12215         void *digest_mem = NULL;
12216         uint32_t segs = 1;
12217         unsigned int to_trn = 0;
12218         struct rte_mbuf *buf = NULL;
12219         uint8_t *auth_tag, *plaintext;
12220         int retval;
12221
12222         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12223                               "No GMAC length in the source data");
12224
12225         /* Verify the capabilities */
12226         struct rte_cryptodev_sym_capability_idx cap_idx;
12227         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12228         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12229         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12230                         &cap_idx) == NULL)
12231                 return TEST_SKIPPED;
12232
12233         /* Check for any input SGL support */
12234         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12235         feature_flags = dev_info.feature_flags;
12236
12237         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12238                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12239                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12240                 return TEST_SKIPPED;
12241
12242         if (fragsz > tdata->plaintext.len)
12243                 fragsz = tdata->plaintext.len;
12244
12245         uint16_t plaintext_len = fragsz;
12246
12247         retval = create_gmac_session(ts_params->valid_devs[0],
12248                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12249
12250         if (retval < 0)
12251                 return retval;
12252
12253         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12254         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12255                         "Failed to allocate input buffer in mempool");
12256
12257         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12258                         rte_pktmbuf_tailroom(ut_params->ibuf));
12259
12260         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12261                                 plaintext_len);
12262         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12263
12264         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12265
12266         trn_data += plaintext_len;
12267
12268         buf = ut_params->ibuf;
12269
12270         /*
12271          * Loop until no more fragments
12272          */
12273
12274         while (trn_data < tdata->plaintext.len) {
12275                 ++segs;
12276                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12277                                 (tdata->plaintext.len - trn_data) : fragsz;
12278
12279                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12280                 buf = buf->next;
12281
12282                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12283                                 rte_pktmbuf_tailroom(buf));
12284
12285                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12286                                 to_trn);
12287
12288                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12289                                 to_trn);
12290                 trn_data += to_trn;
12291                 if (trn_data  == tdata->plaintext.len)
12292                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12293                                         tdata->gmac_tag.len);
12294         }
12295         ut_params->ibuf->nb_segs = segs;
12296
12297         /*
12298          * Place digest at the end of the last buffer
12299          */
12300         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12301
12302         if (!digest_mem) {
12303                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12304                                 + tdata->gmac_tag.len);
12305                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12306                                 tdata->plaintext.len);
12307         }
12308
12309         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12310                         tdata, digest_mem, digest_phys);
12311
12312         if (retval < 0)
12313                 return retval;
12314
12315         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12316
12317         ut_params->op->sym->m_src = ut_params->ibuf;
12318
12319         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12320                 return TEST_SKIPPED;
12321
12322         TEST_ASSERT_NOT_NULL(
12323                 process_crypto_request(ts_params->valid_devs[0],
12324                 ut_params->op), "failed to process sym crypto op");
12325
12326         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12327                         "crypto op processing failed");
12328
12329         auth_tag = digest_mem;
12330         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12331         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12332                         auth_tag,
12333                         tdata->gmac_tag.data,
12334                         tdata->gmac_tag.len,
12335                         "GMAC Generated auth tag not as expected");
12336
12337         return 0;
12338 }
12339
12340 /* Segment size not multiple of block size (16B) */
12341 static int
12342 test_AES_GMAC_authentication_SGL_40B(void)
12343 {
12344         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12345 }
12346
12347 static int
12348 test_AES_GMAC_authentication_SGL_80B(void)
12349 {
12350         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12351 }
12352
12353 static int
12354 test_AES_GMAC_authentication_SGL_2048B(void)
12355 {
12356         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12357 }
12358
12359 /* Segment size not multiple of block size (16B) */
12360 static int
12361 test_AES_GMAC_authentication_SGL_2047B(void)
12362 {
12363         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12364 }
12365
12366 struct test_crypto_vector {
12367         enum rte_crypto_cipher_algorithm crypto_algo;
12368         unsigned int cipher_offset;
12369         unsigned int cipher_len;
12370
12371         struct {
12372                 uint8_t data[64];
12373                 unsigned int len;
12374         } cipher_key;
12375
12376         struct {
12377                 uint8_t data[64];
12378                 unsigned int len;
12379         } iv;
12380
12381         struct {
12382                 const uint8_t *data;
12383                 unsigned int len;
12384         } plaintext;
12385
12386         struct {
12387                 const uint8_t *data;
12388                 unsigned int len;
12389         } ciphertext;
12390
12391         enum rte_crypto_auth_algorithm auth_algo;
12392         unsigned int auth_offset;
12393
12394         struct {
12395                 uint8_t data[128];
12396                 unsigned int len;
12397         } auth_key;
12398
12399         struct {
12400                 const uint8_t *data;
12401                 unsigned int len;
12402         } aad;
12403
12404         struct {
12405                 uint8_t data[128];
12406                 unsigned int len;
12407         } digest;
12408 };
12409
12410 static const struct test_crypto_vector
12411 hmac_sha1_test_crypto_vector = {
12412         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12413         .plaintext = {
12414                 .data = plaintext_hash,
12415                 .len = 512
12416         },
12417         .auth_key = {
12418                 .data = {
12419                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12420                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12421                         0xDE, 0xF4, 0xDE, 0xAD
12422                 },
12423                 .len = 20
12424         },
12425         .digest = {
12426                 .data = {
12427                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12428                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12429                         0x3F, 0x91, 0x64, 0x59
12430                 },
12431                 .len = 20
12432         }
12433 };
12434
12435 static const struct test_crypto_vector
12436 aes128_gmac_test_vector = {
12437         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12438         .plaintext = {
12439                 .data = plaintext_hash,
12440                 .len = 512
12441         },
12442         .iv = {
12443                 .data = {
12444                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12445                         0x08, 0x09, 0x0A, 0x0B
12446                 },
12447                 .len = 12
12448         },
12449         .auth_key = {
12450                 .data = {
12451                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12452                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12453                 },
12454                 .len = 16
12455         },
12456         .digest = {
12457                 .data = {
12458                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12459                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12460                 },
12461                 .len = 16
12462         }
12463 };
12464
12465 static const struct test_crypto_vector
12466 aes128cbc_hmac_sha1_test_vector = {
12467         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12468         .cipher_offset = 0,
12469         .cipher_len = 512,
12470         .cipher_key = {
12471                 .data = {
12472                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12473                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12474                 },
12475                 .len = 16
12476         },
12477         .iv = {
12478                 .data = {
12479                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12480                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12481                 },
12482                 .len = 16
12483         },
12484         .plaintext = {
12485                 .data = plaintext_hash,
12486                 .len = 512
12487         },
12488         .ciphertext = {
12489                 .data = ciphertext512_aes128cbc,
12490                 .len = 512
12491         },
12492         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12493         .auth_offset = 0,
12494         .auth_key = {
12495                 .data = {
12496                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12497                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12498                         0xDE, 0xF4, 0xDE, 0xAD
12499                 },
12500                 .len = 20
12501         },
12502         .digest = {
12503                 .data = {
12504                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12505                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12506                         0x18, 0x8C, 0x1D, 0x32
12507                 },
12508                 .len = 20
12509         }
12510 };
12511
12512 static const struct test_crypto_vector
12513 aes128cbc_hmac_sha1_aad_test_vector = {
12514         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12515         .cipher_offset = 8,
12516         .cipher_len = 496,
12517         .cipher_key = {
12518                 .data = {
12519                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12520                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12521                 },
12522                 .len = 16
12523         },
12524         .iv = {
12525                 .data = {
12526                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12527                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12528                 },
12529                 .len = 16
12530         },
12531         .plaintext = {
12532                 .data = plaintext_hash,
12533                 .len = 512
12534         },
12535         .ciphertext = {
12536                 .data = ciphertext512_aes128cbc_aad,
12537                 .len = 512
12538         },
12539         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12540         .auth_offset = 0,
12541         .auth_key = {
12542                 .data = {
12543                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12544                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12545                         0xDE, 0xF4, 0xDE, 0xAD
12546                 },
12547                 .len = 20
12548         },
12549         .digest = {
12550                 .data = {
12551                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12552                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12553                         0x62, 0x0F, 0xFB, 0x10
12554                 },
12555                 .len = 20
12556         }
12557 };
12558
12559 static void
12560 data_corruption(uint8_t *data)
12561 {
12562         data[0] += 1;
12563 }
12564
12565 static void
12566 tag_corruption(uint8_t *data, unsigned int tag_offset)
12567 {
12568         data[tag_offset] += 1;
12569 }
12570
12571 static int
12572 create_auth_session(struct crypto_unittest_params *ut_params,
12573                 uint8_t dev_id,
12574                 const struct test_crypto_vector *reference,
12575                 enum rte_crypto_auth_operation auth_op)
12576 {
12577         struct crypto_testsuite_params *ts_params = &testsuite_params;
12578         uint8_t auth_key[reference->auth_key.len + 1];
12579
12580         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12581
12582         /* Setup Authentication Parameters */
12583         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12584         ut_params->auth_xform.auth.op = auth_op;
12585         ut_params->auth_xform.next = NULL;
12586         ut_params->auth_xform.auth.algo = reference->auth_algo;
12587         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12588         ut_params->auth_xform.auth.key.data = auth_key;
12589         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12590
12591         /* Create Crypto session*/
12592         ut_params->sess = rte_cryptodev_sym_session_create(
12593                         ts_params->session_mpool);
12594
12595         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12596                                 &ut_params->auth_xform,
12597                                 ts_params->session_priv_mpool);
12598
12599         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12600
12601         return 0;
12602 }
12603
12604 static int
12605 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12606                 uint8_t dev_id,
12607                 const struct test_crypto_vector *reference,
12608                 enum rte_crypto_auth_operation auth_op,
12609                 enum rte_crypto_cipher_operation cipher_op)
12610 {
12611         struct crypto_testsuite_params *ts_params = &testsuite_params;
12612         uint8_t cipher_key[reference->cipher_key.len + 1];
12613         uint8_t auth_key[reference->auth_key.len + 1];
12614
12615         memcpy(cipher_key, reference->cipher_key.data,
12616                         reference->cipher_key.len);
12617         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12618
12619         /* Setup Authentication Parameters */
12620         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12621         ut_params->auth_xform.auth.op = auth_op;
12622         ut_params->auth_xform.auth.algo = reference->auth_algo;
12623         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12624         ut_params->auth_xform.auth.key.data = auth_key;
12625         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12626
12627         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12628                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12629                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12630         } else {
12631                 ut_params->auth_xform.next = &ut_params->cipher_xform;
12632
12633                 /* Setup Cipher Parameters */
12634                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12635                 ut_params->cipher_xform.next = NULL;
12636                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12637                 ut_params->cipher_xform.cipher.op = cipher_op;
12638                 ut_params->cipher_xform.cipher.key.data = cipher_key;
12639                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12640                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12641                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12642         }
12643
12644         /* Create Crypto session*/
12645         ut_params->sess = rte_cryptodev_sym_session_create(
12646                         ts_params->session_mpool);
12647
12648         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12649                                 &ut_params->auth_xform,
12650                                 ts_params->session_priv_mpool);
12651
12652         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12653
12654         return 0;
12655 }
12656
12657 static int
12658 create_auth_operation(struct crypto_testsuite_params *ts_params,
12659                 struct crypto_unittest_params *ut_params,
12660                 const struct test_crypto_vector *reference,
12661                 unsigned int auth_generate)
12662 {
12663         /* Generate Crypto op data structure */
12664         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12665                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12666         TEST_ASSERT_NOT_NULL(ut_params->op,
12667                         "Failed to allocate pktmbuf offload");
12668
12669         /* Set crypto operation data parameters */
12670         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12671
12672         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12673
12674         /* set crypto operation source mbuf */
12675         sym_op->m_src = ut_params->ibuf;
12676
12677         /* digest */
12678         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12679                         ut_params->ibuf, reference->digest.len);
12680
12681         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12682                         "no room to append auth tag");
12683
12684         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12685                         ut_params->ibuf, reference->plaintext.len);
12686
12687         if (auth_generate)
12688                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12689         else
12690                 memcpy(sym_op->auth.digest.data,
12691                                 reference->digest.data,
12692                                 reference->digest.len);
12693
12694         debug_hexdump(stdout, "digest:",
12695                         sym_op->auth.digest.data,
12696                         reference->digest.len);
12697
12698         sym_op->auth.data.length = reference->plaintext.len;
12699         sym_op->auth.data.offset = 0;
12700
12701         return 0;
12702 }
12703
12704 static int
12705 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12706                 struct crypto_unittest_params *ut_params,
12707                 const struct test_crypto_vector *reference,
12708                 unsigned int auth_generate)
12709 {
12710         /* Generate Crypto op data structure */
12711         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12712                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12713         TEST_ASSERT_NOT_NULL(ut_params->op,
12714                         "Failed to allocate pktmbuf offload");
12715
12716         /* Set crypto operation data parameters */
12717         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12718
12719         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12720
12721         /* set crypto operation source mbuf */
12722         sym_op->m_src = ut_params->ibuf;
12723
12724         /* digest */
12725         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12726                         ut_params->ibuf, reference->digest.len);
12727
12728         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12729                         "no room to append auth tag");
12730
12731         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12732                         ut_params->ibuf, reference->ciphertext.len);
12733
12734         if (auth_generate)
12735                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12736         else
12737                 memcpy(sym_op->auth.digest.data,
12738                                 reference->digest.data,
12739                                 reference->digest.len);
12740
12741         debug_hexdump(stdout, "digest:",
12742                         sym_op->auth.digest.data,
12743                         reference->digest.len);
12744
12745         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12746                         reference->iv.data, reference->iv.len);
12747
12748         sym_op->cipher.data.length = 0;
12749         sym_op->cipher.data.offset = 0;
12750
12751         sym_op->auth.data.length = reference->plaintext.len;
12752         sym_op->auth.data.offset = 0;
12753
12754         return 0;
12755 }
12756
12757 static int
12758 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
12759                 struct crypto_unittest_params *ut_params,
12760                 const struct test_crypto_vector *reference,
12761                 unsigned int auth_generate)
12762 {
12763         /* Generate Crypto op data structure */
12764         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12765                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12766         TEST_ASSERT_NOT_NULL(ut_params->op,
12767                         "Failed to allocate pktmbuf offload");
12768
12769         /* Set crypto operation data parameters */
12770         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12771
12772         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12773
12774         /* set crypto operation source mbuf */
12775         sym_op->m_src = ut_params->ibuf;
12776
12777         /* digest */
12778         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12779                         ut_params->ibuf, reference->digest.len);
12780
12781         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12782                         "no room to append auth tag");
12783
12784         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12785                         ut_params->ibuf, reference->ciphertext.len);
12786
12787         if (auth_generate)
12788                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12789         else
12790                 memcpy(sym_op->auth.digest.data,
12791                                 reference->digest.data,
12792                                 reference->digest.len);
12793
12794         debug_hexdump(stdout, "digest:",
12795                         sym_op->auth.digest.data,
12796                         reference->digest.len);
12797
12798         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
12799                         reference->iv.data, reference->iv.len);
12800
12801         sym_op->cipher.data.length = reference->cipher_len;
12802         sym_op->cipher.data.offset = reference->cipher_offset;
12803
12804         sym_op->auth.data.length = reference->plaintext.len;
12805         sym_op->auth.data.offset = reference->auth_offset;
12806
12807         return 0;
12808 }
12809
12810 static int
12811 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12812                 struct crypto_unittest_params *ut_params,
12813                 const struct test_crypto_vector *reference)
12814 {
12815         return create_auth_operation(ts_params, ut_params, reference, 0);
12816 }
12817
12818 static int
12819 create_auth_verify_GMAC_operation(
12820                 struct crypto_testsuite_params *ts_params,
12821                 struct crypto_unittest_params *ut_params,
12822                 const struct test_crypto_vector *reference)
12823 {
12824         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
12825 }
12826
12827 static int
12828 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
12829                 struct crypto_unittest_params *ut_params,
12830                 const struct test_crypto_vector *reference)
12831 {
12832         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
12833 }
12834
12835 static int
12836 test_authentication_verify_fail_when_data_corruption(
12837                 struct crypto_testsuite_params *ts_params,
12838                 struct crypto_unittest_params *ut_params,
12839                 const struct test_crypto_vector *reference,
12840                 unsigned int data_corrupted)
12841 {
12842         int retval;
12843
12844         uint8_t *plaintext;
12845         struct rte_cryptodev_info dev_info;
12846
12847         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12848         uint64_t feat_flags = dev_info.feature_flags;
12849
12850         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12851                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12852                 printf("Device doesn't support RAW data-path APIs.\n");
12853                 return TEST_SKIPPED;
12854         }
12855
12856         /* Verify the capabilities */
12857         struct rte_cryptodev_sym_capability_idx cap_idx;
12858         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12859         cap_idx.algo.auth = reference->auth_algo;
12860         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12861                         &cap_idx) == NULL)
12862                 return TEST_SKIPPED;
12863
12864
12865         /* Create session */
12866         retval = create_auth_session(ut_params,
12867                         ts_params->valid_devs[0],
12868                         reference,
12869                         RTE_CRYPTO_AUTH_OP_VERIFY);
12870         if (retval < 0)
12871                 return retval;
12872
12873         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12874         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12875                         "Failed to allocate input buffer in mempool");
12876
12877         /* clear mbuf payload */
12878         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12879                         rte_pktmbuf_tailroom(ut_params->ibuf));
12880
12881         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12882                         reference->plaintext.len);
12883         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12884         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12885
12886         debug_hexdump(stdout, "plaintext:", plaintext,
12887                 reference->plaintext.len);
12888
12889         /* Create operation */
12890         retval = create_auth_verify_operation(ts_params, ut_params, reference);
12891
12892         if (retval < 0)
12893                 return retval;
12894
12895         if (data_corrupted)
12896                 data_corruption(plaintext);
12897         else
12898                 tag_corruption(plaintext, reference->plaintext.len);
12899
12900         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12901                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12902                         ut_params->op);
12903                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12904                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12905                         "authentication not failed");
12906         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12907                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12908                                 ut_params->op, 0, 1, 0, 0);
12909         else {
12910                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12911                         ut_params->op);
12912                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12913         }
12914
12915         return 0;
12916 }
12917
12918 static int
12919 test_authentication_verify_GMAC_fail_when_corruption(
12920                 struct crypto_testsuite_params *ts_params,
12921                 struct crypto_unittest_params *ut_params,
12922                 const struct test_crypto_vector *reference,
12923                 unsigned int data_corrupted)
12924 {
12925         int retval;
12926         uint8_t *plaintext;
12927         struct rte_cryptodev_info dev_info;
12928
12929         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12930         uint64_t feat_flags = dev_info.feature_flags;
12931
12932         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12933                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12934                 printf("Device doesn't support RAW data-path APIs.\n");
12935                 return TEST_SKIPPED;
12936         }
12937
12938         /* Verify the capabilities */
12939         struct rte_cryptodev_sym_capability_idx cap_idx;
12940         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12941         cap_idx.algo.auth = reference->auth_algo;
12942         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12943                         &cap_idx) == NULL)
12944                 return TEST_SKIPPED;
12945
12946         /* Create session */
12947         retval = create_auth_cipher_session(ut_params,
12948                         ts_params->valid_devs[0],
12949                         reference,
12950                         RTE_CRYPTO_AUTH_OP_VERIFY,
12951                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
12952         if (retval < 0)
12953                 return retval;
12954
12955         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12956         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12957                         "Failed to allocate input buffer in mempool");
12958
12959         /* clear mbuf payload */
12960         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12961                         rte_pktmbuf_tailroom(ut_params->ibuf));
12962
12963         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12964                         reference->plaintext.len);
12965         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12966         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12967
12968         debug_hexdump(stdout, "plaintext:", plaintext,
12969                 reference->plaintext.len);
12970
12971         /* Create operation */
12972         retval = create_auth_verify_GMAC_operation(ts_params,
12973                         ut_params,
12974                         reference);
12975
12976         if (retval < 0)
12977                 return retval;
12978
12979         if (data_corrupted)
12980                 data_corruption(plaintext);
12981         else
12982                 tag_corruption(plaintext, reference->aad.len);
12983
12984         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12985                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12986                         ut_params->op);
12987                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12988                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12989                         "authentication not failed");
12990         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12991                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12992                                 ut_params->op, 0, 1, 0, 0);
12993         else {
12994                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12995                         ut_params->op);
12996                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12997         }
12998
12999         return 0;
13000 }
13001
13002 static int
13003 test_authenticated_decryption_fail_when_corruption(
13004                 struct crypto_testsuite_params *ts_params,
13005                 struct crypto_unittest_params *ut_params,
13006                 const struct test_crypto_vector *reference,
13007                 unsigned int data_corrupted)
13008 {
13009         int retval;
13010
13011         uint8_t *ciphertext;
13012         struct rte_cryptodev_info dev_info;
13013
13014         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13015         uint64_t feat_flags = dev_info.feature_flags;
13016
13017         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13018                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13019                 printf("Device doesn't support RAW data-path APIs.\n");
13020                 return TEST_SKIPPED;
13021         }
13022
13023         /* Verify the capabilities */
13024         struct rte_cryptodev_sym_capability_idx cap_idx;
13025         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13026         cap_idx.algo.auth = reference->auth_algo;
13027         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13028                         &cap_idx) == NULL)
13029                 return TEST_SKIPPED;
13030         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13031         cap_idx.algo.cipher = reference->crypto_algo;
13032         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13033                         &cap_idx) == NULL)
13034                 return TEST_SKIPPED;
13035
13036         /* Create session */
13037         retval = create_auth_cipher_session(ut_params,
13038                         ts_params->valid_devs[0],
13039                         reference,
13040                         RTE_CRYPTO_AUTH_OP_VERIFY,
13041                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13042         if (retval < 0)
13043                 return retval;
13044
13045         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13046         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13047                         "Failed to allocate input buffer in mempool");
13048
13049         /* clear mbuf payload */
13050         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13051                         rte_pktmbuf_tailroom(ut_params->ibuf));
13052
13053         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13054                         reference->ciphertext.len);
13055         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13056         memcpy(ciphertext, reference->ciphertext.data,
13057                         reference->ciphertext.len);
13058
13059         /* Create operation */
13060         retval = create_cipher_auth_verify_operation(ts_params,
13061                         ut_params,
13062                         reference);
13063
13064         if (retval < 0)
13065                 return retval;
13066
13067         if (data_corrupted)
13068                 data_corruption(ciphertext);
13069         else
13070                 tag_corruption(ciphertext, reference->ciphertext.len);
13071
13072         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13073                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13074                         ut_params->op);
13075                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13076                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13077                         "authentication not failed");
13078         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13079                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13080                                 ut_params->op, 1, 1, 0, 0);
13081         else {
13082                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13083                         ut_params->op);
13084                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13085         }
13086
13087         return 0;
13088 }
13089
13090 static int
13091 test_authenticated_encrypt_with_esn(
13092                 struct crypto_testsuite_params *ts_params,
13093                 struct crypto_unittest_params *ut_params,
13094                 const struct test_crypto_vector *reference)
13095 {
13096         int retval;
13097
13098         uint8_t *authciphertext, *plaintext, *auth_tag;
13099         uint16_t plaintext_pad_len;
13100         uint8_t cipher_key[reference->cipher_key.len + 1];
13101         uint8_t auth_key[reference->auth_key.len + 1];
13102         struct rte_cryptodev_info dev_info;
13103
13104         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13105         uint64_t feat_flags = dev_info.feature_flags;
13106
13107         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13108                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13109                 printf("Device doesn't support RAW data-path APIs.\n");
13110                 return TEST_SKIPPED;
13111         }
13112
13113         /* Verify the capabilities */
13114         struct rte_cryptodev_sym_capability_idx cap_idx;
13115         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13116         cap_idx.algo.auth = reference->auth_algo;
13117         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13118                         &cap_idx) == NULL)
13119                 return TEST_SKIPPED;
13120         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13121         cap_idx.algo.cipher = reference->crypto_algo;
13122         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13123                         &cap_idx) == NULL)
13124                 return TEST_SKIPPED;
13125
13126         /* Create session */
13127         memcpy(cipher_key, reference->cipher_key.data,
13128                         reference->cipher_key.len);
13129         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13130
13131         /* Setup Cipher Parameters */
13132         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13133         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13134         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13135         ut_params->cipher_xform.cipher.key.data = cipher_key;
13136         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13137         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13138         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13139
13140         ut_params->cipher_xform.next = &ut_params->auth_xform;
13141
13142         /* Setup Authentication Parameters */
13143         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13144         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13145         ut_params->auth_xform.auth.algo = reference->auth_algo;
13146         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13147         ut_params->auth_xform.auth.key.data = auth_key;
13148         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13149         ut_params->auth_xform.next = NULL;
13150
13151         /* Create Crypto session*/
13152         ut_params->sess = rte_cryptodev_sym_session_create(
13153                         ts_params->session_mpool);
13154
13155         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13156                                 ut_params->sess,
13157                                 &ut_params->cipher_xform,
13158                                 ts_params->session_priv_mpool);
13159
13160         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13161
13162         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13163         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13164                         "Failed to allocate input buffer in mempool");
13165
13166         /* clear mbuf payload */
13167         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13168                         rte_pktmbuf_tailroom(ut_params->ibuf));
13169
13170         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13171                         reference->plaintext.len);
13172         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13173         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13174
13175         /* Create operation */
13176         retval = create_cipher_auth_operation(ts_params,
13177                         ut_params,
13178                         reference, 0);
13179
13180         if (retval < 0)
13181                 return retval;
13182
13183         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13184                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13185                         ut_params->op);
13186         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13187                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13188                                 ut_params->op, 1, 1, 0, 0);
13189         else
13190                 ut_params->op = process_crypto_request(
13191                         ts_params->valid_devs[0], ut_params->op);
13192
13193         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13194
13195         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13196                         "crypto op processing failed");
13197
13198         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13199
13200         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13201                         ut_params->op->sym->auth.data.offset);
13202         auth_tag = authciphertext + plaintext_pad_len;
13203         debug_hexdump(stdout, "ciphertext:", authciphertext,
13204                         reference->ciphertext.len);
13205         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13206
13207         /* Validate obuf */
13208         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13209                         authciphertext,
13210                         reference->ciphertext.data,
13211                         reference->ciphertext.len,
13212                         "Ciphertext data not as expected");
13213
13214         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13215                         auth_tag,
13216                         reference->digest.data,
13217                         reference->digest.len,
13218                         "Generated digest not as expected");
13219
13220         return TEST_SUCCESS;
13221
13222 }
13223
13224 static int
13225 test_authenticated_decrypt_with_esn(
13226                 struct crypto_testsuite_params *ts_params,
13227                 struct crypto_unittest_params *ut_params,
13228                 const struct test_crypto_vector *reference)
13229 {
13230         int retval;
13231
13232         uint8_t *ciphertext;
13233         uint8_t cipher_key[reference->cipher_key.len + 1];
13234         uint8_t auth_key[reference->auth_key.len + 1];
13235         struct rte_cryptodev_info dev_info;
13236
13237         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13238         uint64_t feat_flags = dev_info.feature_flags;
13239
13240         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13241                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13242                 printf("Device doesn't support RAW data-path APIs.\n");
13243                 return TEST_SKIPPED;
13244         }
13245
13246         /* Verify the capabilities */
13247         struct rte_cryptodev_sym_capability_idx cap_idx;
13248         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13249         cap_idx.algo.auth = reference->auth_algo;
13250         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13251                         &cap_idx) == NULL)
13252                 return TEST_SKIPPED;
13253         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13254         cap_idx.algo.cipher = reference->crypto_algo;
13255         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13256                         &cap_idx) == NULL)
13257                 return TEST_SKIPPED;
13258
13259         /* Create session */
13260         memcpy(cipher_key, reference->cipher_key.data,
13261                         reference->cipher_key.len);
13262         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13263
13264         /* Setup Authentication Parameters */
13265         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13266         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13267         ut_params->auth_xform.auth.algo = reference->auth_algo;
13268         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13269         ut_params->auth_xform.auth.key.data = auth_key;
13270         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13271         ut_params->auth_xform.next = &ut_params->cipher_xform;
13272
13273         /* Setup Cipher Parameters */
13274         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13275         ut_params->cipher_xform.next = NULL;
13276         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13277         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13278         ut_params->cipher_xform.cipher.key.data = cipher_key;
13279         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13280         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13281         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13282
13283         /* Create Crypto session*/
13284         ut_params->sess = rte_cryptodev_sym_session_create(
13285                         ts_params->session_mpool);
13286
13287         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13288                                 ut_params->sess,
13289                                 &ut_params->auth_xform,
13290                                 ts_params->session_priv_mpool);
13291
13292         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13293
13294         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13295         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13296                         "Failed to allocate input buffer in mempool");
13297
13298         /* clear mbuf payload */
13299         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13300                         rte_pktmbuf_tailroom(ut_params->ibuf));
13301
13302         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13303                         reference->ciphertext.len);
13304         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13305         memcpy(ciphertext, reference->ciphertext.data,
13306                         reference->ciphertext.len);
13307
13308         /* Create operation */
13309         retval = create_cipher_auth_verify_operation(ts_params,
13310                         ut_params,
13311                         reference);
13312
13313         if (retval < 0)
13314                 return retval;
13315
13316         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13317                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13318                         ut_params->op);
13319         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13320                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13321                                 ut_params->op, 1, 1, 0, 0);
13322         else
13323                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13324                         ut_params->op);
13325
13326         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13327         TEST_ASSERT_EQUAL(ut_params->op->status,
13328                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13329                         "crypto op processing passed");
13330
13331         ut_params->obuf = ut_params->op->sym->m_src;
13332         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13333
13334         return 0;
13335 }
13336
13337 static int
13338 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13339                 const struct aead_test_data *tdata,
13340                 void *digest_mem, uint64_t digest_phys)
13341 {
13342         struct crypto_testsuite_params *ts_params = &testsuite_params;
13343         struct crypto_unittest_params *ut_params = &unittest_params;
13344
13345         const unsigned int auth_tag_len = tdata->auth_tag.len;
13346         const unsigned int iv_len = tdata->iv.len;
13347         unsigned int aad_len = tdata->aad.len;
13348         unsigned int aad_len_pad = 0;
13349
13350         /* Generate Crypto op data structure */
13351         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13352                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13353         TEST_ASSERT_NOT_NULL(ut_params->op,
13354                 "Failed to allocate symmetric crypto operation struct");
13355
13356         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13357
13358         sym_op->aead.digest.data = digest_mem;
13359
13360         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13361                         "no room to append digest");
13362
13363         sym_op->aead.digest.phys_addr = digest_phys;
13364
13365         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13366                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13367                                 auth_tag_len);
13368                 debug_hexdump(stdout, "digest:",
13369                                 sym_op->aead.digest.data,
13370                                 auth_tag_len);
13371         }
13372
13373         /* Append aad data */
13374         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13375                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13376                                 uint8_t *, IV_OFFSET);
13377
13378                 /* Copy IV 1 byte after the IV pointer, according to the API */
13379                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13380
13381                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13382
13383                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13384                                 ut_params->ibuf, aad_len);
13385                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13386                                 "no room to prepend aad");
13387                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13388                                 ut_params->ibuf);
13389
13390                 memset(sym_op->aead.aad.data, 0, aad_len);
13391                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13392                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13393
13394                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13395                 debug_hexdump(stdout, "aad:",
13396                                 sym_op->aead.aad.data, aad_len);
13397         } else {
13398                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13399                                 uint8_t *, IV_OFFSET);
13400
13401                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13402
13403                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13404
13405                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13406                                 ut_params->ibuf, aad_len_pad);
13407                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13408                                 "no room to prepend aad");
13409                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13410                                 ut_params->ibuf);
13411
13412                 memset(sym_op->aead.aad.data, 0, aad_len);
13413                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13414
13415                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13416                 debug_hexdump(stdout, "aad:",
13417                                 sym_op->aead.aad.data, aad_len);
13418         }
13419
13420         sym_op->aead.data.length = tdata->plaintext.len;
13421         sym_op->aead.data.offset = aad_len_pad;
13422
13423         return 0;
13424 }
13425
13426 #define SGL_MAX_NO      16
13427
13428 static int
13429 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13430                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13431 {
13432         struct crypto_testsuite_params *ts_params = &testsuite_params;
13433         struct crypto_unittest_params *ut_params = &unittest_params;
13434         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13435         int retval;
13436         int to_trn = 0;
13437         int to_trn_tbl[SGL_MAX_NO];
13438         int segs = 1;
13439         unsigned int trn_data = 0;
13440         uint8_t *plaintext, *ciphertext, *auth_tag;
13441         struct rte_cryptodev_info dev_info;
13442
13443         /* Verify the capabilities */
13444         struct rte_cryptodev_sym_capability_idx cap_idx;
13445         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13446         cap_idx.algo.aead = tdata->algo;
13447         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13448                         &cap_idx) == NULL)
13449                 return TEST_SKIPPED;
13450
13451         /* OOP not supported with CPU crypto */
13452         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13453                 return TEST_SKIPPED;
13454
13455         /* Detailed check for the particular SGL support flag */
13456         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13457         if (!oop) {
13458                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13459                 if (sgl_in && (!(dev_info.feature_flags &
13460                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13461                         return TEST_SKIPPED;
13462
13463                 uint64_t feat_flags = dev_info.feature_flags;
13464
13465                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13466                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13467                         printf("Device doesn't support RAW data-path APIs.\n");
13468                         return TEST_SKIPPED;
13469                 }
13470         } else {
13471                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13472                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13473                                 tdata->plaintext.len;
13474                 /* Raw data path API does not support OOP */
13475                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13476                         return TEST_SKIPPED;
13477                 if (sgl_in && !sgl_out) {
13478                         if (!(dev_info.feature_flags &
13479                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13480                                 return TEST_SKIPPED;
13481                 } else if (!sgl_in && sgl_out) {
13482                         if (!(dev_info.feature_flags &
13483                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13484                                 return TEST_SKIPPED;
13485                 } else if (sgl_in && sgl_out) {
13486                         if (!(dev_info.feature_flags &
13487                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13488                                 return TEST_SKIPPED;
13489                 }
13490         }
13491
13492         if (fragsz > tdata->plaintext.len)
13493                 fragsz = tdata->plaintext.len;
13494
13495         uint16_t plaintext_len = fragsz;
13496         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13497
13498         if (fragsz_oop > tdata->plaintext.len)
13499                 frag_size_oop = tdata->plaintext.len;
13500
13501         int ecx = 0;
13502         void *digest_mem = NULL;
13503
13504         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13505
13506         if (tdata->plaintext.len % fragsz != 0) {
13507                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13508                         return 1;
13509         }       else {
13510                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13511                         return 1;
13512         }
13513
13514         /*
13515          * For out-op-place we need to alloc another mbuf
13516          */
13517         if (oop) {
13518                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13519                 rte_pktmbuf_append(ut_params->obuf,
13520                                 frag_size_oop + prepend_len);
13521                 buf_oop = ut_params->obuf;
13522         }
13523
13524         /* Create AEAD session */
13525         retval = create_aead_session(ts_params->valid_devs[0],
13526                         tdata->algo,
13527                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13528                         tdata->key.data, tdata->key.len,
13529                         tdata->aad.len, tdata->auth_tag.len,
13530                         tdata->iv.len);
13531         if (retval < 0)
13532                 return retval;
13533
13534         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13535
13536         /* clear mbuf payload */
13537         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13538                         rte_pktmbuf_tailroom(ut_params->ibuf));
13539
13540         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13541                         plaintext_len);
13542
13543         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13544
13545         trn_data += plaintext_len;
13546
13547         buf = ut_params->ibuf;
13548
13549         /*
13550          * Loop until no more fragments
13551          */
13552
13553         while (trn_data < tdata->plaintext.len) {
13554                 ++segs;
13555                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13556                                 (tdata->plaintext.len - trn_data) : fragsz;
13557
13558                 to_trn_tbl[ecx++] = to_trn;
13559
13560                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13561                 buf = buf->next;
13562
13563                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13564                                 rte_pktmbuf_tailroom(buf));
13565
13566                 /* OOP */
13567                 if (oop && !fragsz_oop) {
13568                         buf_last_oop = buf_oop->next =
13569                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13570                         buf_oop = buf_oop->next;
13571                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13572                                         0, rte_pktmbuf_tailroom(buf_oop));
13573                         rte_pktmbuf_append(buf_oop, to_trn);
13574                 }
13575
13576                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13577                                 to_trn);
13578
13579                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13580                                 to_trn);
13581                 trn_data += to_trn;
13582                 if (trn_data  == tdata->plaintext.len) {
13583                         if (oop) {
13584                                 if (!fragsz_oop)
13585                                         digest_mem = rte_pktmbuf_append(buf_oop,
13586                                                 tdata->auth_tag.len);
13587                         } else
13588                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13589                                         tdata->auth_tag.len);
13590                 }
13591         }
13592
13593         uint64_t digest_phys = 0;
13594
13595         ut_params->ibuf->nb_segs = segs;
13596
13597         segs = 1;
13598         if (fragsz_oop && oop) {
13599                 to_trn = 0;
13600                 ecx = 0;
13601
13602                 if (frag_size_oop == tdata->plaintext.len) {
13603                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
13604                                 tdata->auth_tag.len);
13605
13606                         digest_phys = rte_pktmbuf_iova_offset(
13607                                         ut_params->obuf,
13608                                         tdata->plaintext.len + prepend_len);
13609                 }
13610
13611                 trn_data = frag_size_oop;
13612                 while (trn_data < tdata->plaintext.len) {
13613                         ++segs;
13614                         to_trn =
13615                                 (tdata->plaintext.len - trn_data <
13616                                                 frag_size_oop) ?
13617                                 (tdata->plaintext.len - trn_data) :
13618                                                 frag_size_oop;
13619
13620                         to_trn_tbl[ecx++] = to_trn;
13621
13622                         buf_last_oop = buf_oop->next =
13623                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13624                         buf_oop = buf_oop->next;
13625                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13626                                         0, rte_pktmbuf_tailroom(buf_oop));
13627                         rte_pktmbuf_append(buf_oop, to_trn);
13628
13629                         trn_data += to_trn;
13630
13631                         if (trn_data  == tdata->plaintext.len) {
13632                                 digest_mem = rte_pktmbuf_append(buf_oop,
13633                                         tdata->auth_tag.len);
13634                         }
13635                 }
13636
13637                 ut_params->obuf->nb_segs = segs;
13638         }
13639
13640         /*
13641          * Place digest at the end of the last buffer
13642          */
13643         if (!digest_phys)
13644                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13645         if (oop && buf_last_oop)
13646                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13647
13648         if (!digest_mem && !oop) {
13649                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13650                                 + tdata->auth_tag.len);
13651                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13652                                 tdata->plaintext.len);
13653         }
13654
13655         /* Create AEAD operation */
13656         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13657                         tdata, digest_mem, digest_phys);
13658
13659         if (retval < 0)
13660                 return retval;
13661
13662         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13663
13664         ut_params->op->sym->m_src = ut_params->ibuf;
13665         if (oop)
13666                 ut_params->op->sym->m_dst = ut_params->obuf;
13667
13668         /* Process crypto operation */
13669         if (oop == IN_PLACE &&
13670                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13671                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13672         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13673                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13674                                 ut_params->op, 0, 0, 0, 0);
13675         else
13676                 TEST_ASSERT_NOT_NULL(
13677                         process_crypto_request(ts_params->valid_devs[0],
13678                         ut_params->op), "failed to process sym crypto op");
13679
13680         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13681                         "crypto op processing failed");
13682
13683
13684         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13685                         uint8_t *, prepend_len);
13686         if (oop) {
13687                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13688                                 uint8_t *, prepend_len);
13689         }
13690
13691         if (fragsz_oop)
13692                 fragsz = fragsz_oop;
13693
13694         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13695                         ciphertext,
13696                         tdata->ciphertext.data,
13697                         fragsz,
13698                         "Ciphertext data not as expected");
13699
13700         buf = ut_params->op->sym->m_src->next;
13701         if (oop)
13702                 buf = ut_params->op->sym->m_dst->next;
13703
13704         unsigned int off = fragsz;
13705
13706         ecx = 0;
13707         while (buf) {
13708                 ciphertext = rte_pktmbuf_mtod(buf,
13709                                 uint8_t *);
13710
13711                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
13712                                 ciphertext,
13713                                 tdata->ciphertext.data + off,
13714                                 to_trn_tbl[ecx],
13715                                 "Ciphertext data not as expected");
13716
13717                 off += to_trn_tbl[ecx++];
13718                 buf = buf->next;
13719         }
13720
13721         auth_tag = digest_mem;
13722         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13723                         auth_tag,
13724                         tdata->auth_tag.data,
13725                         tdata->auth_tag.len,
13726                         "Generated auth tag not as expected");
13727
13728         return 0;
13729 }
13730
13731 static int
13732 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
13733 {
13734         return test_authenticated_encryption_SGL(
13735                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
13736 }
13737
13738 static int
13739 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
13740 {
13741         return test_authenticated_encryption_SGL(
13742                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
13743 }
13744
13745 static int
13746 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
13747 {
13748         return test_authenticated_encryption_SGL(
13749                         &gcm_test_case_8, OUT_OF_PLACE, 400,
13750                         gcm_test_case_8.plaintext.len);
13751 }
13752
13753 static int
13754 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
13755 {
13756         /* This test is not for OPENSSL PMD */
13757         if (gbl_driver_id == rte_cryptodev_driver_id_get(
13758                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
13759                 return TEST_SKIPPED;
13760
13761         return test_authenticated_encryption_SGL(
13762                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
13763 }
13764
13765 static int
13766 test_authentication_verify_fail_when_data_corrupted(
13767                 struct crypto_testsuite_params *ts_params,
13768                 struct crypto_unittest_params *ut_params,
13769                 const struct test_crypto_vector *reference)
13770 {
13771         return test_authentication_verify_fail_when_data_corruption(
13772                         ts_params, ut_params, reference, 1);
13773 }
13774
13775 static int
13776 test_authentication_verify_fail_when_tag_corrupted(
13777                 struct crypto_testsuite_params *ts_params,
13778                 struct crypto_unittest_params *ut_params,
13779                 const struct test_crypto_vector *reference)
13780 {
13781         return test_authentication_verify_fail_when_data_corruption(
13782                         ts_params, ut_params, reference, 0);
13783 }
13784
13785 static int
13786 test_authentication_verify_GMAC_fail_when_data_corrupted(
13787                 struct crypto_testsuite_params *ts_params,
13788                 struct crypto_unittest_params *ut_params,
13789                 const struct test_crypto_vector *reference)
13790 {
13791         return test_authentication_verify_GMAC_fail_when_corruption(
13792                         ts_params, ut_params, reference, 1);
13793 }
13794
13795 static int
13796 test_authentication_verify_GMAC_fail_when_tag_corrupted(
13797                 struct crypto_testsuite_params *ts_params,
13798                 struct crypto_unittest_params *ut_params,
13799                 const struct test_crypto_vector *reference)
13800 {
13801         return test_authentication_verify_GMAC_fail_when_corruption(
13802                         ts_params, ut_params, reference, 0);
13803 }
13804
13805 static int
13806 test_authenticated_decryption_fail_when_data_corrupted(
13807                 struct crypto_testsuite_params *ts_params,
13808                 struct crypto_unittest_params *ut_params,
13809                 const struct test_crypto_vector *reference)
13810 {
13811         return test_authenticated_decryption_fail_when_corruption(
13812                         ts_params, ut_params, reference, 1);
13813 }
13814
13815 static int
13816 test_authenticated_decryption_fail_when_tag_corrupted(
13817                 struct crypto_testsuite_params *ts_params,
13818                 struct crypto_unittest_params *ut_params,
13819                 const struct test_crypto_vector *reference)
13820 {
13821         return test_authenticated_decryption_fail_when_corruption(
13822                         ts_params, ut_params, reference, 0);
13823 }
13824
13825 static int
13826 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
13827 {
13828         return test_authentication_verify_fail_when_data_corrupted(
13829                         &testsuite_params, &unittest_params,
13830                         &hmac_sha1_test_crypto_vector);
13831 }
13832
13833 static int
13834 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
13835 {
13836         return test_authentication_verify_fail_when_tag_corrupted(
13837                         &testsuite_params, &unittest_params,
13838                         &hmac_sha1_test_crypto_vector);
13839 }
13840
13841 static int
13842 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
13843 {
13844         return test_authentication_verify_GMAC_fail_when_data_corrupted(
13845                         &testsuite_params, &unittest_params,
13846                         &aes128_gmac_test_vector);
13847 }
13848
13849 static int
13850 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
13851 {
13852         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
13853                         &testsuite_params, &unittest_params,
13854                         &aes128_gmac_test_vector);
13855 }
13856
13857 static int
13858 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
13859 {
13860         return test_authenticated_decryption_fail_when_data_corrupted(
13861                         &testsuite_params,
13862                         &unittest_params,
13863                         &aes128cbc_hmac_sha1_test_vector);
13864 }
13865
13866 static int
13867 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
13868 {
13869         return test_authenticated_decryption_fail_when_tag_corrupted(
13870                         &testsuite_params,
13871                         &unittest_params,
13872                         &aes128cbc_hmac_sha1_test_vector);
13873 }
13874
13875 static int
13876 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13877 {
13878         return test_authenticated_encrypt_with_esn(
13879                         &testsuite_params,
13880                         &unittest_params,
13881                         &aes128cbc_hmac_sha1_aad_test_vector);
13882 }
13883
13884 static int
13885 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13886 {
13887         return test_authenticated_decrypt_with_esn(
13888                         &testsuite_params,
13889                         &unittest_params,
13890                         &aes128cbc_hmac_sha1_aad_test_vector);
13891 }
13892
13893 static int
13894 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
13895 {
13896         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
13897 }
13898
13899 static int
13900 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
13901 {
13902         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
13903 }
13904
13905 #ifdef RTE_CRYPTO_SCHEDULER
13906
13907 /* global AESNI worker IDs for the scheduler test */
13908 uint8_t aesni_ids[2];
13909
13910 static int
13911 scheduler_testsuite_setup(void)
13912 {
13913         uint32_t i = 0;
13914         int32_t nb_devs, ret;
13915         char vdev_args[VDEV_ARGS_SIZE] = {""};
13916         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
13917                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
13918         uint16_t worker_core_count = 0;
13919         uint16_t socket_id = 0;
13920
13921         if (gbl_driver_id == rte_cryptodev_driver_id_get(
13922                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
13923
13924                 /* Identify the Worker Cores
13925                  * Use 2 worker cores for the device args
13926                  */
13927                 RTE_LCORE_FOREACH_WORKER(i) {
13928                         if (worker_core_count > 1)
13929                                 break;
13930                         snprintf(vdev_args, sizeof(vdev_args),
13931                                         "%s%d", temp_str, i);
13932                         strcpy(temp_str, vdev_args);
13933                         strlcat(temp_str, ";", sizeof(temp_str));
13934                         worker_core_count++;
13935                         socket_id = rte_lcore_to_socket_id(i);
13936                 }
13937                 if (worker_core_count != 2) {
13938                         RTE_LOG(ERR, USER1,
13939                                 "Cryptodev scheduler test require at least "
13940                                 "two worker cores to run. "
13941                                 "Please use the correct coremask.\n");
13942                         return TEST_FAILED;
13943                 }
13944                 strcpy(temp_str, vdev_args);
13945                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
13946                                 temp_str, socket_id);
13947                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
13948                 nb_devs = rte_cryptodev_device_count_by_driver(
13949                                 rte_cryptodev_driver_id_get(
13950                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
13951                 if (nb_devs < 1) {
13952                         ret = rte_vdev_init(
13953                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
13954                                         vdev_args);
13955                         TEST_ASSERT(ret == 0,
13956                                 "Failed to create instance %u of pmd : %s",
13957                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13958                 }
13959         }
13960         return testsuite_setup();
13961 }
13962
13963 static int
13964 test_scheduler_attach_worker_op(void)
13965 {
13966         struct crypto_testsuite_params *ts_params = &testsuite_params;
13967         uint8_t sched_id = ts_params->valid_devs[0];
13968         uint32_t i, nb_devs_attached = 0;
13969         int ret;
13970         char vdev_name[32];
13971         unsigned int count = rte_cryptodev_count();
13972
13973         /* create 2 AESNI_MB vdevs on top of existing devices */
13974         for (i = count; i < count + 2; i++) {
13975                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
13976                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
13977                                 i);
13978                 ret = rte_vdev_init(vdev_name, NULL);
13979
13980                 TEST_ASSERT(ret == 0,
13981                         "Failed to create instance %u of"
13982                         " pmd : %s",
13983                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13984
13985                 if (ret < 0) {
13986                         RTE_LOG(ERR, USER1,
13987                                 "Failed to create 2 AESNI MB PMDs.\n");
13988                         return TEST_SKIPPED;
13989                 }
13990         }
13991
13992         /* attach 2 AESNI_MB cdevs */
13993         for (i = count; i < count + 2; i++) {
13994                 struct rte_cryptodev_info info;
13995                 unsigned int session_size;
13996
13997                 rte_cryptodev_info_get(i, &info);
13998                 if (info.driver_id != rte_cryptodev_driver_id_get(
13999                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14000                         continue;
14001
14002                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14003                 /*
14004                  * Create the session mempool again, since now there are new devices
14005                  * to use the mempool.
14006                  */
14007                 if (ts_params->session_mpool) {
14008                         rte_mempool_free(ts_params->session_mpool);
14009                         ts_params->session_mpool = NULL;
14010                 }
14011                 if (ts_params->session_priv_mpool) {
14012                         rte_mempool_free(ts_params->session_priv_mpool);
14013                         ts_params->session_priv_mpool = NULL;
14014                 }
14015
14016                 if (info.sym.max_nb_sessions != 0 &&
14017                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14018                         RTE_LOG(ERR, USER1,
14019                                         "Device does not support "
14020                                         "at least %u sessions\n",
14021                                         MAX_NB_SESSIONS);
14022                         return TEST_FAILED;
14023                 }
14024                 /*
14025                  * Create mempool with maximum number of sessions,
14026                  * to include the session headers
14027                  */
14028                 if (ts_params->session_mpool == NULL) {
14029                         ts_params->session_mpool =
14030                                 rte_cryptodev_sym_session_pool_create(
14031                                                 "test_sess_mp",
14032                                                 MAX_NB_SESSIONS, 0, 0, 0,
14033                                                 SOCKET_ID_ANY);
14034                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14035                                         "session mempool allocation failed");
14036                 }
14037
14038                 /*
14039                  * Create mempool with maximum number of sessions,
14040                  * to include device specific session private data
14041                  */
14042                 if (ts_params->session_priv_mpool == NULL) {
14043                         ts_params->session_priv_mpool = rte_mempool_create(
14044                                         "test_sess_mp_priv",
14045                                         MAX_NB_SESSIONS,
14046                                         session_size,
14047                                         0, 0, NULL, NULL, NULL,
14048                                         NULL, SOCKET_ID_ANY,
14049                                         0);
14050
14051                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14052                                         "session mempool allocation failed");
14053                 }
14054
14055                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14056                 ts_params->qp_conf.mp_session_private =
14057                                 ts_params->session_priv_mpool;
14058
14059                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14060                                 (uint8_t)i);
14061
14062                 TEST_ASSERT(ret == 0,
14063                         "Failed to attach device %u of pmd : %s", i,
14064                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14065
14066                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14067
14068                 nb_devs_attached++;
14069         }
14070
14071         return 0;
14072 }
14073
14074 static int
14075 test_scheduler_detach_worker_op(void)
14076 {
14077         struct crypto_testsuite_params *ts_params = &testsuite_params;
14078         uint8_t sched_id = ts_params->valid_devs[0];
14079         uint32_t i;
14080         int ret;
14081
14082         for (i = 0; i < 2; i++) {
14083                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14084                                 aesni_ids[i]);
14085                 TEST_ASSERT(ret == 0,
14086                         "Failed to detach device %u", aesni_ids[i]);
14087         }
14088
14089         return 0;
14090 }
14091
14092 static int
14093 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14094 {
14095         struct crypto_testsuite_params *ts_params = &testsuite_params;
14096         uint8_t sched_id = ts_params->valid_devs[0];
14097         /* set mode */
14098         return rte_cryptodev_scheduler_mode_set(sched_id,
14099                 scheduler_mode);
14100 }
14101
14102 static int
14103 test_scheduler_mode_roundrobin_op(void)
14104 {
14105         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14106                         0, "Failed to set roundrobin mode");
14107         return 0;
14108
14109 }
14110
14111 static int
14112 test_scheduler_mode_multicore_op(void)
14113 {
14114         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14115                         0, "Failed to set multicore mode");
14116
14117         return 0;
14118 }
14119
14120 static int
14121 test_scheduler_mode_failover_op(void)
14122 {
14123         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14124                         0, "Failed to set failover mode");
14125
14126         return 0;
14127 }
14128
14129 static int
14130 test_scheduler_mode_pkt_size_distr_op(void)
14131 {
14132         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14133                         0, "Failed to set pktsize mode");
14134
14135         return 0;
14136 }
14137
14138 static int
14139 scheduler_multicore_testsuite_setup(void)
14140 {
14141         if (test_scheduler_attach_worker_op() < 0)
14142                 return TEST_SKIPPED;
14143         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14144                 return TEST_SKIPPED;
14145         return 0;
14146 }
14147
14148 static int
14149 scheduler_roundrobin_testsuite_setup(void)
14150 {
14151         if (test_scheduler_attach_worker_op() < 0)
14152                 return TEST_SKIPPED;
14153         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14154                 return TEST_SKIPPED;
14155         return 0;
14156 }
14157
14158 static int
14159 scheduler_failover_testsuite_setup(void)
14160 {
14161         if (test_scheduler_attach_worker_op() < 0)
14162                 return TEST_SKIPPED;
14163         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14164                 return TEST_SKIPPED;
14165         return 0;
14166 }
14167
14168 static int
14169 scheduler_pkt_size_distr_testsuite_setup(void)
14170 {
14171         if (test_scheduler_attach_worker_op() < 0)
14172                 return TEST_SKIPPED;
14173         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14174                 return TEST_SKIPPED;
14175         return 0;
14176 }
14177
14178 static void
14179 scheduler_mode_testsuite_teardown(void)
14180 {
14181         test_scheduler_detach_worker_op();
14182 }
14183
14184 #endif /* RTE_CRYPTO_SCHEDULER */
14185
14186 static struct unit_test_suite end_testsuite = {
14187         .suite_name = NULL,
14188         .setup = NULL,
14189         .teardown = NULL,
14190         .unit_test_suites = NULL
14191 };
14192
14193 #ifdef RTE_LIB_SECURITY
14194 static struct unit_test_suite ipsec_proto_testsuite  = {
14195         .suite_name = "IPsec Proto Unit Test Suite",
14196         .setup = ipsec_proto_testsuite_setup,
14197         .unit_test_cases = {
14198                 TEST_CASE_NAMED_WITH_DATA(
14199                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14200                         ut_setup_security, ut_teardown,
14201                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14202                 TEST_CASE_NAMED_WITH_DATA(
14203                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14204                         ut_setup_security, ut_teardown,
14205                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14206                 TEST_CASE_NAMED_WITH_DATA(
14207                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14208                         ut_setup_security, ut_teardown,
14209                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14210                 TEST_CASE_NAMED_WITH_DATA(
14211                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14212                         ut_setup_security, ut_teardown,
14213                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14214                 TEST_CASE_NAMED_WITH_DATA(
14215                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14216                         ut_setup_security, ut_teardown,
14217                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14218                 TEST_CASE_NAMED_WITH_DATA(
14219                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14220                         ut_setup_security, ut_teardown,
14221                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14222                 TEST_CASE_NAMED_ST(
14223                         "Combined test alg list",
14224                         ut_setup_security, ut_teardown,
14225                         test_ipsec_proto_display_list),
14226                 TEST_CASE_NAMED_ST(
14227                         "IV generation",
14228                         ut_setup_security, ut_teardown,
14229                         test_ipsec_proto_iv_gen),
14230                 TEST_CASE_NAMED_ST(
14231                         "UDP encapsulation",
14232                         ut_setup_security, ut_teardown,
14233                         test_ipsec_proto_udp_encap),
14234                 TEST_CASE_NAMED_ST(
14235                         "UDP encapsulation ports verification test",
14236                         ut_setup_security, ut_teardown,
14237                         test_ipsec_proto_udp_ports_verify),
14238                 TEST_CASE_NAMED_ST(
14239                         "SA expiry packets soft",
14240                         ut_setup_security, ut_teardown,
14241                         test_ipsec_proto_sa_exp_pkts_soft),
14242                 TEST_CASE_NAMED_ST(
14243                         "SA expiry packets hard",
14244                         ut_setup_security, ut_teardown,
14245                         test_ipsec_proto_sa_exp_pkts_hard),
14246                 TEST_CASE_NAMED_ST(
14247                         "Negative test: ICV corruption",
14248                         ut_setup_security, ut_teardown,
14249                         test_ipsec_proto_err_icv_corrupt),
14250                 TEST_CASE_NAMED_ST(
14251                         "Tunnel dst addr verification",
14252                         ut_setup_security, ut_teardown,
14253                         test_ipsec_proto_tunnel_dst_addr_verify),
14254                 TEST_CASE_NAMED_ST(
14255                         "Tunnel src and dst addr verification",
14256                         ut_setup_security, ut_teardown,
14257                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14258                 TEST_CASES_END() /**< NULL terminate unit test array */
14259         }
14260 };
14261
14262 static struct unit_test_suite pdcp_proto_testsuite  = {
14263         .suite_name = "PDCP Proto Unit Test Suite",
14264         .setup = pdcp_proto_testsuite_setup,
14265         .unit_test_cases = {
14266                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14267                         test_PDCP_PROTO_all),
14268                 TEST_CASES_END() /**< NULL terminate unit test array */
14269         }
14270 };
14271
14272 static struct unit_test_suite docsis_proto_testsuite  = {
14273         .suite_name = "Docsis Proto Unit Test Suite",
14274         .setup = docsis_proto_testsuite_setup,
14275         .unit_test_cases = {
14276                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14277                         test_DOCSIS_PROTO_all),
14278                 TEST_CASES_END() /**< NULL terminate unit test array */
14279         }
14280 };
14281 #endif
14282
14283 static struct unit_test_suite cryptodev_gen_testsuite  = {
14284         .suite_name = "Crypto General Unit Test Suite",
14285         .setup = crypto_gen_testsuite_setup,
14286         .unit_test_cases = {
14287                 TEST_CASE_ST(ut_setup, ut_teardown,
14288                                 test_device_configure_invalid_dev_id),
14289                 TEST_CASE_ST(ut_setup, ut_teardown,
14290                                 test_queue_pair_descriptor_setup),
14291                 TEST_CASE_ST(ut_setup, ut_teardown,
14292                                 test_device_configure_invalid_queue_pair_ids),
14293                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14294                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14295                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14296                 TEST_CASES_END() /**< NULL terminate unit test array */
14297         }
14298 };
14299
14300 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14301         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14302         .setup = negative_hmac_sha1_testsuite_setup,
14303         .unit_test_cases = {
14304                 /** Negative tests */
14305                 TEST_CASE_ST(ut_setup, ut_teardown,
14306                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14307                 TEST_CASE_ST(ut_setup, ut_teardown,
14308                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14309                 TEST_CASE_ST(ut_setup, ut_teardown,
14310                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14311                 TEST_CASE_ST(ut_setup, ut_teardown,
14312                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14313
14314                 TEST_CASES_END() /**< NULL terminate unit test array */
14315         }
14316 };
14317
14318 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14319         .suite_name = "Multi Session Unit Test Suite",
14320         .setup = multi_session_testsuite_setup,
14321         .unit_test_cases = {
14322                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14323                 TEST_CASE_ST(ut_setup, ut_teardown,
14324                                 test_multi_session_random_usage),
14325
14326                 TEST_CASES_END() /**< NULL terminate unit test array */
14327         }
14328 };
14329
14330 static struct unit_test_suite cryptodev_null_testsuite  = {
14331         .suite_name = "NULL Test Suite",
14332         .setup = null_testsuite_setup,
14333         .unit_test_cases = {
14334                 TEST_CASE_ST(ut_setup, ut_teardown,
14335                         test_null_invalid_operation),
14336                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14337                 TEST_CASES_END()
14338         }
14339 };
14340
14341 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
14342         .suite_name = "AES CCM Authenticated Test Suite",
14343         .setup = aes_ccm_auth_testsuite_setup,
14344         .unit_test_cases = {
14345                 /** AES CCM Authenticated Encryption 128 bits key*/
14346                 TEST_CASE_ST(ut_setup, ut_teardown,
14347                         test_AES_CCM_authenticated_encryption_test_case_128_1),
14348                 TEST_CASE_ST(ut_setup, ut_teardown,
14349                         test_AES_CCM_authenticated_encryption_test_case_128_2),
14350                 TEST_CASE_ST(ut_setup, ut_teardown,
14351                         test_AES_CCM_authenticated_encryption_test_case_128_3),
14352
14353                 /** AES CCM Authenticated Decryption 128 bits key*/
14354                 TEST_CASE_ST(ut_setup, ut_teardown,
14355                         test_AES_CCM_authenticated_decryption_test_case_128_1),
14356                 TEST_CASE_ST(ut_setup, ut_teardown,
14357                         test_AES_CCM_authenticated_decryption_test_case_128_2),
14358                 TEST_CASE_ST(ut_setup, ut_teardown,
14359                         test_AES_CCM_authenticated_decryption_test_case_128_3),
14360
14361                 /** AES CCM Authenticated Encryption 192 bits key */
14362                 TEST_CASE_ST(ut_setup, ut_teardown,
14363                         test_AES_CCM_authenticated_encryption_test_case_192_1),
14364                 TEST_CASE_ST(ut_setup, ut_teardown,
14365                         test_AES_CCM_authenticated_encryption_test_case_192_2),
14366                 TEST_CASE_ST(ut_setup, ut_teardown,
14367                         test_AES_CCM_authenticated_encryption_test_case_192_3),
14368
14369                 /** AES CCM Authenticated Decryption 192 bits key*/
14370                 TEST_CASE_ST(ut_setup, ut_teardown,
14371                         test_AES_CCM_authenticated_decryption_test_case_192_1),
14372                 TEST_CASE_ST(ut_setup, ut_teardown,
14373                         test_AES_CCM_authenticated_decryption_test_case_192_2),
14374                 TEST_CASE_ST(ut_setup, ut_teardown,
14375                         test_AES_CCM_authenticated_decryption_test_case_192_3),
14376
14377                 /** AES CCM Authenticated Encryption 256 bits key */
14378                 TEST_CASE_ST(ut_setup, ut_teardown,
14379                         test_AES_CCM_authenticated_encryption_test_case_256_1),
14380                 TEST_CASE_ST(ut_setup, ut_teardown,
14381                         test_AES_CCM_authenticated_encryption_test_case_256_2),
14382                 TEST_CASE_ST(ut_setup, ut_teardown,
14383                         test_AES_CCM_authenticated_encryption_test_case_256_3),
14384
14385                 /** AES CCM Authenticated Decryption 256 bits key*/
14386                 TEST_CASE_ST(ut_setup, ut_teardown,
14387                         test_AES_CCM_authenticated_decryption_test_case_256_1),
14388                 TEST_CASE_ST(ut_setup, ut_teardown,
14389                         test_AES_CCM_authenticated_decryption_test_case_256_2),
14390                 TEST_CASE_ST(ut_setup, ut_teardown,
14391                         test_AES_CCM_authenticated_decryption_test_case_256_3),
14392                 TEST_CASES_END()
14393         }
14394 };
14395
14396 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
14397         .suite_name = "AES GCM Authenticated Test Suite",
14398         .setup = aes_gcm_auth_testsuite_setup,
14399         .unit_test_cases = {
14400                 /** AES GCM Authenticated Encryption */
14401                 TEST_CASE_ST(ut_setup, ut_teardown,
14402                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14403                 TEST_CASE_ST(ut_setup, ut_teardown,
14404                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14405                 TEST_CASE_ST(ut_setup, ut_teardown,
14406                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14407                 TEST_CASE_ST(ut_setup, ut_teardown,
14408                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14409                 TEST_CASE_ST(ut_setup, ut_teardown,
14410                         test_AES_GCM_authenticated_encryption_test_case_1),
14411                 TEST_CASE_ST(ut_setup, ut_teardown,
14412                         test_AES_GCM_authenticated_encryption_test_case_2),
14413                 TEST_CASE_ST(ut_setup, ut_teardown,
14414                         test_AES_GCM_authenticated_encryption_test_case_3),
14415                 TEST_CASE_ST(ut_setup, ut_teardown,
14416                         test_AES_GCM_authenticated_encryption_test_case_4),
14417                 TEST_CASE_ST(ut_setup, ut_teardown,
14418                         test_AES_GCM_authenticated_encryption_test_case_5),
14419                 TEST_CASE_ST(ut_setup, ut_teardown,
14420                         test_AES_GCM_authenticated_encryption_test_case_6),
14421                 TEST_CASE_ST(ut_setup, ut_teardown,
14422                         test_AES_GCM_authenticated_encryption_test_case_7),
14423                 TEST_CASE_ST(ut_setup, ut_teardown,
14424                         test_AES_GCM_authenticated_encryption_test_case_8),
14425                 TEST_CASE_ST(ut_setup, ut_teardown,
14426                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
14427
14428                 /** AES GCM Authenticated Decryption */
14429                 TEST_CASE_ST(ut_setup, ut_teardown,
14430                         test_AES_GCM_authenticated_decryption_test_case_1),
14431                 TEST_CASE_ST(ut_setup, ut_teardown,
14432                         test_AES_GCM_authenticated_decryption_test_case_2),
14433                 TEST_CASE_ST(ut_setup, ut_teardown,
14434                         test_AES_GCM_authenticated_decryption_test_case_3),
14435                 TEST_CASE_ST(ut_setup, ut_teardown,
14436                         test_AES_GCM_authenticated_decryption_test_case_4),
14437                 TEST_CASE_ST(ut_setup, ut_teardown,
14438                         test_AES_GCM_authenticated_decryption_test_case_5),
14439                 TEST_CASE_ST(ut_setup, ut_teardown,
14440                         test_AES_GCM_authenticated_decryption_test_case_6),
14441                 TEST_CASE_ST(ut_setup, ut_teardown,
14442                         test_AES_GCM_authenticated_decryption_test_case_7),
14443                 TEST_CASE_ST(ut_setup, ut_teardown,
14444                         test_AES_GCM_authenticated_decryption_test_case_8),
14445                 TEST_CASE_ST(ut_setup, ut_teardown,
14446                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
14447
14448                 /** AES GCM Authenticated Encryption 192 bits key */
14449                 TEST_CASE_ST(ut_setup, ut_teardown,
14450                         test_AES_GCM_auth_encryption_test_case_192_1),
14451                 TEST_CASE_ST(ut_setup, ut_teardown,
14452                         test_AES_GCM_auth_encryption_test_case_192_2),
14453                 TEST_CASE_ST(ut_setup, ut_teardown,
14454                         test_AES_GCM_auth_encryption_test_case_192_3),
14455                 TEST_CASE_ST(ut_setup, ut_teardown,
14456                         test_AES_GCM_auth_encryption_test_case_192_4),
14457                 TEST_CASE_ST(ut_setup, ut_teardown,
14458                         test_AES_GCM_auth_encryption_test_case_192_5),
14459                 TEST_CASE_ST(ut_setup, ut_teardown,
14460                         test_AES_GCM_auth_encryption_test_case_192_6),
14461                 TEST_CASE_ST(ut_setup, ut_teardown,
14462                         test_AES_GCM_auth_encryption_test_case_192_7),
14463
14464                 /** AES GCM Authenticated Decryption 192 bits key */
14465                 TEST_CASE_ST(ut_setup, ut_teardown,
14466                         test_AES_GCM_auth_decryption_test_case_192_1),
14467                 TEST_CASE_ST(ut_setup, ut_teardown,
14468                         test_AES_GCM_auth_decryption_test_case_192_2),
14469                 TEST_CASE_ST(ut_setup, ut_teardown,
14470                         test_AES_GCM_auth_decryption_test_case_192_3),
14471                 TEST_CASE_ST(ut_setup, ut_teardown,
14472                         test_AES_GCM_auth_decryption_test_case_192_4),
14473                 TEST_CASE_ST(ut_setup, ut_teardown,
14474                         test_AES_GCM_auth_decryption_test_case_192_5),
14475                 TEST_CASE_ST(ut_setup, ut_teardown,
14476                         test_AES_GCM_auth_decryption_test_case_192_6),
14477                 TEST_CASE_ST(ut_setup, ut_teardown,
14478                         test_AES_GCM_auth_decryption_test_case_192_7),
14479
14480                 /** AES GCM Authenticated Encryption 256 bits key */
14481                 TEST_CASE_ST(ut_setup, ut_teardown,
14482                         test_AES_GCM_auth_encryption_test_case_256_1),
14483                 TEST_CASE_ST(ut_setup, ut_teardown,
14484                         test_AES_GCM_auth_encryption_test_case_256_2),
14485                 TEST_CASE_ST(ut_setup, ut_teardown,
14486                         test_AES_GCM_auth_encryption_test_case_256_3),
14487                 TEST_CASE_ST(ut_setup, ut_teardown,
14488                         test_AES_GCM_auth_encryption_test_case_256_4),
14489                 TEST_CASE_ST(ut_setup, ut_teardown,
14490                         test_AES_GCM_auth_encryption_test_case_256_5),
14491                 TEST_CASE_ST(ut_setup, ut_teardown,
14492                         test_AES_GCM_auth_encryption_test_case_256_6),
14493                 TEST_CASE_ST(ut_setup, ut_teardown,
14494                         test_AES_GCM_auth_encryption_test_case_256_7),
14495
14496                 /** AES GCM Authenticated Decryption 256 bits key */
14497                 TEST_CASE_ST(ut_setup, ut_teardown,
14498                         test_AES_GCM_auth_decryption_test_case_256_1),
14499                 TEST_CASE_ST(ut_setup, ut_teardown,
14500                         test_AES_GCM_auth_decryption_test_case_256_2),
14501                 TEST_CASE_ST(ut_setup, ut_teardown,
14502                         test_AES_GCM_auth_decryption_test_case_256_3),
14503                 TEST_CASE_ST(ut_setup, ut_teardown,
14504                         test_AES_GCM_auth_decryption_test_case_256_4),
14505                 TEST_CASE_ST(ut_setup, ut_teardown,
14506                         test_AES_GCM_auth_decryption_test_case_256_5),
14507                 TEST_CASE_ST(ut_setup, ut_teardown,
14508                         test_AES_GCM_auth_decryption_test_case_256_6),
14509                 TEST_CASE_ST(ut_setup, ut_teardown,
14510                         test_AES_GCM_auth_decryption_test_case_256_7),
14511
14512                 /** AES GCM Authenticated Encryption big aad size */
14513                 TEST_CASE_ST(ut_setup, ut_teardown,
14514                         test_AES_GCM_auth_encryption_test_case_aad_1),
14515                 TEST_CASE_ST(ut_setup, ut_teardown,
14516                         test_AES_GCM_auth_encryption_test_case_aad_2),
14517
14518                 /** AES GCM Authenticated Decryption big aad size */
14519                 TEST_CASE_ST(ut_setup, ut_teardown,
14520                         test_AES_GCM_auth_decryption_test_case_aad_1),
14521                 TEST_CASE_ST(ut_setup, ut_teardown,
14522                         test_AES_GCM_auth_decryption_test_case_aad_2),
14523
14524                 /** Out of place tests */
14525                 TEST_CASE_ST(ut_setup, ut_teardown,
14526                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
14527                 TEST_CASE_ST(ut_setup, ut_teardown,
14528                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
14529
14530                 /** Session-less tests */
14531                 TEST_CASE_ST(ut_setup, ut_teardown,
14532                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
14533                 TEST_CASE_ST(ut_setup, ut_teardown,
14534                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
14535
14536                 TEST_CASES_END()
14537         }
14538 };
14539
14540 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
14541         .suite_name = "AES GMAC Authentication Test Suite",
14542         .setup = aes_gmac_auth_testsuite_setup,
14543         .unit_test_cases = {
14544                 TEST_CASE_ST(ut_setup, ut_teardown,
14545                         test_AES_GMAC_authentication_test_case_1),
14546                 TEST_CASE_ST(ut_setup, ut_teardown,
14547                         test_AES_GMAC_authentication_verify_test_case_1),
14548                 TEST_CASE_ST(ut_setup, ut_teardown,
14549                         test_AES_GMAC_authentication_test_case_2),
14550                 TEST_CASE_ST(ut_setup, ut_teardown,
14551                         test_AES_GMAC_authentication_verify_test_case_2),
14552                 TEST_CASE_ST(ut_setup, ut_teardown,
14553                         test_AES_GMAC_authentication_test_case_3),
14554                 TEST_CASE_ST(ut_setup, ut_teardown,
14555                         test_AES_GMAC_authentication_verify_test_case_3),
14556                 TEST_CASE_ST(ut_setup, ut_teardown,
14557                         test_AES_GMAC_authentication_test_case_4),
14558                 TEST_CASE_ST(ut_setup, ut_teardown,
14559                         test_AES_GMAC_authentication_verify_test_case_4),
14560                 TEST_CASE_ST(ut_setup, ut_teardown,
14561                         test_AES_GMAC_authentication_SGL_40B),
14562                 TEST_CASE_ST(ut_setup, ut_teardown,
14563                         test_AES_GMAC_authentication_SGL_80B),
14564                 TEST_CASE_ST(ut_setup, ut_teardown,
14565                         test_AES_GMAC_authentication_SGL_2048B),
14566                 TEST_CASE_ST(ut_setup, ut_teardown,
14567                         test_AES_GMAC_authentication_SGL_2047B),
14568
14569                 TEST_CASES_END()
14570         }
14571 };
14572
14573 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
14574         .suite_name = "Chacha20-Poly1305 Test Suite",
14575         .setup = chacha20_poly1305_testsuite_setup,
14576         .unit_test_cases = {
14577                 TEST_CASE_ST(ut_setup, ut_teardown,
14578                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
14579                 TEST_CASE_ST(ut_setup, ut_teardown,
14580                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
14581                 TEST_CASES_END()
14582         }
14583 };
14584
14585 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
14586         .suite_name = "SNOW 3G Test Suite",
14587         .setup = snow3g_testsuite_setup,
14588         .unit_test_cases = {
14589                 /** SNOW 3G encrypt only (UEA2) */
14590                 TEST_CASE_ST(ut_setup, ut_teardown,
14591                         test_snow3g_encryption_test_case_1),
14592                 TEST_CASE_ST(ut_setup, ut_teardown,
14593                         test_snow3g_encryption_test_case_2),
14594                 TEST_CASE_ST(ut_setup, ut_teardown,
14595                         test_snow3g_encryption_test_case_3),
14596                 TEST_CASE_ST(ut_setup, ut_teardown,
14597                         test_snow3g_encryption_test_case_4),
14598                 TEST_CASE_ST(ut_setup, ut_teardown,
14599                         test_snow3g_encryption_test_case_5),
14600
14601                 TEST_CASE_ST(ut_setup, ut_teardown,
14602                         test_snow3g_encryption_test_case_1_oop),
14603                 TEST_CASE_ST(ut_setup, ut_teardown,
14604                         test_snow3g_encryption_test_case_1_oop_sgl),
14605                 TEST_CASE_ST(ut_setup, ut_teardown,
14606                         test_snow3g_encryption_test_case_1_offset_oop),
14607                 TEST_CASE_ST(ut_setup, ut_teardown,
14608                         test_snow3g_decryption_test_case_1_oop),
14609
14610                 /** SNOW 3G generate auth, then encrypt (UEA2) */
14611                 TEST_CASE_ST(ut_setup, ut_teardown,
14612                         test_snow3g_auth_cipher_test_case_1),
14613                 TEST_CASE_ST(ut_setup, ut_teardown,
14614                         test_snow3g_auth_cipher_test_case_2),
14615                 TEST_CASE_ST(ut_setup, ut_teardown,
14616                         test_snow3g_auth_cipher_test_case_2_oop),
14617                 TEST_CASE_ST(ut_setup, ut_teardown,
14618                         test_snow3g_auth_cipher_part_digest_enc),
14619                 TEST_CASE_ST(ut_setup, ut_teardown,
14620                         test_snow3g_auth_cipher_part_digest_enc_oop),
14621                 TEST_CASE_ST(ut_setup, ut_teardown,
14622                         test_snow3g_auth_cipher_test_case_3_sgl),
14623                 TEST_CASE_ST(ut_setup, ut_teardown,
14624                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
14625                 TEST_CASE_ST(ut_setup, ut_teardown,
14626                         test_snow3g_auth_cipher_part_digest_enc_sgl),
14627                 TEST_CASE_ST(ut_setup, ut_teardown,
14628                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
14629
14630                 /** SNOW 3G decrypt (UEA2), then verify auth */
14631                 TEST_CASE_ST(ut_setup, ut_teardown,
14632                         test_snow3g_auth_cipher_verify_test_case_1),
14633                 TEST_CASE_ST(ut_setup, ut_teardown,
14634                         test_snow3g_auth_cipher_verify_test_case_2),
14635                 TEST_CASE_ST(ut_setup, ut_teardown,
14636                         test_snow3g_auth_cipher_verify_test_case_2_oop),
14637                 TEST_CASE_ST(ut_setup, ut_teardown,
14638                         test_snow3g_auth_cipher_verify_part_digest_enc),
14639                 TEST_CASE_ST(ut_setup, ut_teardown,
14640                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
14641                 TEST_CASE_ST(ut_setup, ut_teardown,
14642                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
14643                 TEST_CASE_ST(ut_setup, ut_teardown,
14644                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
14645                 TEST_CASE_ST(ut_setup, ut_teardown,
14646                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
14647                 TEST_CASE_ST(ut_setup, ut_teardown,
14648                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
14649
14650                 /** SNOW 3G decrypt only (UEA2) */
14651                 TEST_CASE_ST(ut_setup, ut_teardown,
14652                         test_snow3g_decryption_test_case_1),
14653                 TEST_CASE_ST(ut_setup, ut_teardown,
14654                         test_snow3g_decryption_test_case_2),
14655                 TEST_CASE_ST(ut_setup, ut_teardown,
14656                         test_snow3g_decryption_test_case_3),
14657                 TEST_CASE_ST(ut_setup, ut_teardown,
14658                         test_snow3g_decryption_test_case_4),
14659                 TEST_CASE_ST(ut_setup, ut_teardown,
14660                         test_snow3g_decryption_test_case_5),
14661                 TEST_CASE_ST(ut_setup, ut_teardown,
14662                         test_snow3g_decryption_with_digest_test_case_1),
14663                 TEST_CASE_ST(ut_setup, ut_teardown,
14664                         test_snow3g_hash_generate_test_case_1),
14665                 TEST_CASE_ST(ut_setup, ut_teardown,
14666                         test_snow3g_hash_generate_test_case_2),
14667                 TEST_CASE_ST(ut_setup, ut_teardown,
14668                         test_snow3g_hash_generate_test_case_3),
14669
14670                 /* Tests with buffers which length is not byte-aligned */
14671                 TEST_CASE_ST(ut_setup, ut_teardown,
14672                         test_snow3g_hash_generate_test_case_4),
14673                 TEST_CASE_ST(ut_setup, ut_teardown,
14674                         test_snow3g_hash_generate_test_case_5),
14675                 TEST_CASE_ST(ut_setup, ut_teardown,
14676                         test_snow3g_hash_generate_test_case_6),
14677                 TEST_CASE_ST(ut_setup, ut_teardown,
14678                         test_snow3g_hash_verify_test_case_1),
14679                 TEST_CASE_ST(ut_setup, ut_teardown,
14680                         test_snow3g_hash_verify_test_case_2),
14681                 TEST_CASE_ST(ut_setup, ut_teardown,
14682                         test_snow3g_hash_verify_test_case_3),
14683
14684                 /* Tests with buffers which length is not byte-aligned */
14685                 TEST_CASE_ST(ut_setup, ut_teardown,
14686                         test_snow3g_hash_verify_test_case_4),
14687                 TEST_CASE_ST(ut_setup, ut_teardown,
14688                         test_snow3g_hash_verify_test_case_5),
14689                 TEST_CASE_ST(ut_setup, ut_teardown,
14690                         test_snow3g_hash_verify_test_case_6),
14691                 TEST_CASE_ST(ut_setup, ut_teardown,
14692                         test_snow3g_cipher_auth_test_case_1),
14693                 TEST_CASE_ST(ut_setup, ut_teardown,
14694                         test_snow3g_auth_cipher_with_digest_test_case_1),
14695                 TEST_CASES_END()
14696         }
14697 };
14698
14699 static struct unit_test_suite cryptodev_zuc_testsuite  = {
14700         .suite_name = "ZUC Test Suite",
14701         .setup = zuc_testsuite_setup,
14702         .unit_test_cases = {
14703                 /** ZUC encrypt only (EEA3) */
14704                 TEST_CASE_ST(ut_setup, ut_teardown,
14705                         test_zuc_encryption_test_case_1),
14706                 TEST_CASE_ST(ut_setup, ut_teardown,
14707                         test_zuc_encryption_test_case_2),
14708                 TEST_CASE_ST(ut_setup, ut_teardown,
14709                         test_zuc_encryption_test_case_3),
14710                 TEST_CASE_ST(ut_setup, ut_teardown,
14711                         test_zuc_encryption_test_case_4),
14712                 TEST_CASE_ST(ut_setup, ut_teardown,
14713                         test_zuc_encryption_test_case_5),
14714                 TEST_CASE_ST(ut_setup, ut_teardown,
14715                         test_zuc_encryption_test_case_6_sgl),
14716                 TEST_CASE_ST(ut_setup, ut_teardown,
14717                         test_zuc_encryption_test_case_7),
14718
14719                 /** ZUC authenticate (EIA3) */
14720                 TEST_CASE_ST(ut_setup, ut_teardown,
14721                         test_zuc_hash_generate_test_case_1),
14722                 TEST_CASE_ST(ut_setup, ut_teardown,
14723                         test_zuc_hash_generate_test_case_2),
14724                 TEST_CASE_ST(ut_setup, ut_teardown,
14725                         test_zuc_hash_generate_test_case_3),
14726                 TEST_CASE_ST(ut_setup, ut_teardown,
14727                         test_zuc_hash_generate_test_case_4),
14728                 TEST_CASE_ST(ut_setup, ut_teardown,
14729                         test_zuc_hash_generate_test_case_5),
14730                 TEST_CASE_ST(ut_setup, ut_teardown,
14731                         test_zuc_hash_generate_test_case_6),
14732                 TEST_CASE_ST(ut_setup, ut_teardown,
14733                         test_zuc_hash_generate_test_case_7),
14734                 TEST_CASE_ST(ut_setup, ut_teardown,
14735                         test_zuc_hash_generate_test_case_8),
14736                 TEST_CASE_ST(ut_setup, ut_teardown,
14737                         test_zuc_hash_generate_test_case_9),
14738                 TEST_CASE_ST(ut_setup, ut_teardown,
14739                         test_zuc_hash_generate_test_case_10),
14740
14741
14742                 /** ZUC alg-chain (EEA3/EIA3) */
14743                 TEST_CASE_ST(ut_setup, ut_teardown,
14744                         test_zuc_cipher_auth_test_case_1),
14745                 TEST_CASE_ST(ut_setup, ut_teardown,
14746                         test_zuc_cipher_auth_test_case_2),
14747
14748                 /** ZUC generate auth, then encrypt (EEA3) */
14749                 TEST_CASE_ST(ut_setup, ut_teardown,
14750                         test_zuc_auth_cipher_test_case_1),
14751                 TEST_CASE_ST(ut_setup, ut_teardown,
14752                         test_zuc_auth_cipher_test_case_1_oop),
14753                 TEST_CASE_ST(ut_setup, ut_teardown,
14754                         test_zuc_auth_cipher_test_case_1_sgl),
14755                 TEST_CASE_ST(ut_setup, ut_teardown,
14756                         test_zuc_auth_cipher_test_case_1_oop_sgl),
14757
14758                 /** ZUC decrypt (EEA3), then verify auth */
14759                 TEST_CASE_ST(ut_setup, ut_teardown,
14760                         test_zuc_auth_cipher_verify_test_case_1),
14761                 TEST_CASE_ST(ut_setup, ut_teardown,
14762                         test_zuc_auth_cipher_verify_test_case_1_oop),
14763                 TEST_CASE_ST(ut_setup, ut_teardown,
14764                         test_zuc_auth_cipher_verify_test_case_1_sgl),
14765                 TEST_CASE_ST(ut_setup, ut_teardown,
14766                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
14767                 TEST_CASES_END()
14768         }
14769 };
14770
14771 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
14772         .suite_name = "HMAC_MD5 Authentication Test Suite",
14773         .setup = hmac_md5_auth_testsuite_setup,
14774         .unit_test_cases = {
14775                 TEST_CASE_ST(ut_setup, ut_teardown,
14776                         test_MD5_HMAC_generate_case_1),
14777                 TEST_CASE_ST(ut_setup, ut_teardown,
14778                         test_MD5_HMAC_verify_case_1),
14779                 TEST_CASE_ST(ut_setup, ut_teardown,
14780                         test_MD5_HMAC_generate_case_2),
14781                 TEST_CASE_ST(ut_setup, ut_teardown,
14782                         test_MD5_HMAC_verify_case_2),
14783                 TEST_CASES_END()
14784         }
14785 };
14786
14787 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
14788         .suite_name = "Kasumi Test Suite",
14789         .setup = kasumi_testsuite_setup,
14790         .unit_test_cases = {
14791                 /** KASUMI hash only (UIA1) */
14792                 TEST_CASE_ST(ut_setup, ut_teardown,
14793                         test_kasumi_hash_generate_test_case_1),
14794                 TEST_CASE_ST(ut_setup, ut_teardown,
14795                         test_kasumi_hash_generate_test_case_2),
14796                 TEST_CASE_ST(ut_setup, ut_teardown,
14797                         test_kasumi_hash_generate_test_case_3),
14798                 TEST_CASE_ST(ut_setup, ut_teardown,
14799                         test_kasumi_hash_generate_test_case_4),
14800                 TEST_CASE_ST(ut_setup, ut_teardown,
14801                         test_kasumi_hash_generate_test_case_5),
14802                 TEST_CASE_ST(ut_setup, ut_teardown,
14803                         test_kasumi_hash_generate_test_case_6),
14804
14805                 TEST_CASE_ST(ut_setup, ut_teardown,
14806                         test_kasumi_hash_verify_test_case_1),
14807                 TEST_CASE_ST(ut_setup, ut_teardown,
14808                         test_kasumi_hash_verify_test_case_2),
14809                 TEST_CASE_ST(ut_setup, ut_teardown,
14810                         test_kasumi_hash_verify_test_case_3),
14811                 TEST_CASE_ST(ut_setup, ut_teardown,
14812                         test_kasumi_hash_verify_test_case_4),
14813                 TEST_CASE_ST(ut_setup, ut_teardown,
14814                         test_kasumi_hash_verify_test_case_5),
14815
14816                 /** KASUMI encrypt only (UEA1) */
14817                 TEST_CASE_ST(ut_setup, ut_teardown,
14818                         test_kasumi_encryption_test_case_1),
14819                 TEST_CASE_ST(ut_setup, ut_teardown,
14820                         test_kasumi_encryption_test_case_1_sgl),
14821                 TEST_CASE_ST(ut_setup, ut_teardown,
14822                         test_kasumi_encryption_test_case_1_oop),
14823                 TEST_CASE_ST(ut_setup, ut_teardown,
14824                         test_kasumi_encryption_test_case_1_oop_sgl),
14825                 TEST_CASE_ST(ut_setup, ut_teardown,
14826                         test_kasumi_encryption_test_case_2),
14827                 TEST_CASE_ST(ut_setup, ut_teardown,
14828                         test_kasumi_encryption_test_case_3),
14829                 TEST_CASE_ST(ut_setup, ut_teardown,
14830                         test_kasumi_encryption_test_case_4),
14831                 TEST_CASE_ST(ut_setup, ut_teardown,
14832                         test_kasumi_encryption_test_case_5),
14833
14834                 /** KASUMI decrypt only (UEA1) */
14835                 TEST_CASE_ST(ut_setup, ut_teardown,
14836                         test_kasumi_decryption_test_case_1),
14837                 TEST_CASE_ST(ut_setup, ut_teardown,
14838                         test_kasumi_decryption_test_case_2),
14839                 TEST_CASE_ST(ut_setup, ut_teardown,
14840                         test_kasumi_decryption_test_case_3),
14841                 TEST_CASE_ST(ut_setup, ut_teardown,
14842                         test_kasumi_decryption_test_case_4),
14843                 TEST_CASE_ST(ut_setup, ut_teardown,
14844                         test_kasumi_decryption_test_case_5),
14845                 TEST_CASE_ST(ut_setup, ut_teardown,
14846                         test_kasumi_decryption_test_case_1_oop),
14847                 TEST_CASE_ST(ut_setup, ut_teardown,
14848                         test_kasumi_cipher_auth_test_case_1),
14849
14850                 /** KASUMI generate auth, then encrypt (F8) */
14851                 TEST_CASE_ST(ut_setup, ut_teardown,
14852                         test_kasumi_auth_cipher_test_case_1),
14853                 TEST_CASE_ST(ut_setup, ut_teardown,
14854                         test_kasumi_auth_cipher_test_case_2),
14855                 TEST_CASE_ST(ut_setup, ut_teardown,
14856                         test_kasumi_auth_cipher_test_case_2_oop),
14857                 TEST_CASE_ST(ut_setup, ut_teardown,
14858                         test_kasumi_auth_cipher_test_case_2_sgl),
14859                 TEST_CASE_ST(ut_setup, ut_teardown,
14860                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
14861
14862                 /** KASUMI decrypt (F8), then verify auth */
14863                 TEST_CASE_ST(ut_setup, ut_teardown,
14864                         test_kasumi_auth_cipher_verify_test_case_1),
14865                 TEST_CASE_ST(ut_setup, ut_teardown,
14866                         test_kasumi_auth_cipher_verify_test_case_2),
14867                 TEST_CASE_ST(ut_setup, ut_teardown,
14868                         test_kasumi_auth_cipher_verify_test_case_2_oop),
14869                 TEST_CASE_ST(ut_setup, ut_teardown,
14870                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
14871                 TEST_CASE_ST(ut_setup, ut_teardown,
14872                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
14873
14874                 TEST_CASES_END()
14875         }
14876 };
14877
14878 static struct unit_test_suite cryptodev_esn_testsuite  = {
14879         .suite_name = "ESN Test Suite",
14880         .setup = esn_testsuite_setup,
14881         .unit_test_cases = {
14882                 TEST_CASE_ST(ut_setup, ut_teardown,
14883                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
14884                 TEST_CASE_ST(ut_setup, ut_teardown,
14885                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
14886                 TEST_CASES_END()
14887         }
14888 };
14889
14890 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
14891         .suite_name = "Negative AES GCM Test Suite",
14892         .setup = negative_aes_gcm_testsuite_setup,
14893         .unit_test_cases = {
14894                 TEST_CASE_ST(ut_setup, ut_teardown,
14895                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
14896                 TEST_CASE_ST(ut_setup, ut_teardown,
14897                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
14898                 TEST_CASE_ST(ut_setup, ut_teardown,
14899                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
14900                 TEST_CASE_ST(ut_setup, ut_teardown,
14901                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
14902                 TEST_CASE_ST(ut_setup, ut_teardown,
14903                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
14904                 TEST_CASE_ST(ut_setup, ut_teardown,
14905                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
14906                 TEST_CASE_ST(ut_setup, ut_teardown,
14907                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
14908                 TEST_CASE_ST(ut_setup, ut_teardown,
14909                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
14910                 TEST_CASE_ST(ut_setup, ut_teardown,
14911                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
14912                 TEST_CASE_ST(ut_setup, ut_teardown,
14913                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
14914                 TEST_CASE_ST(ut_setup, ut_teardown,
14915                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
14916                 TEST_CASE_ST(ut_setup, ut_teardown,
14917                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
14918
14919                 TEST_CASES_END()
14920         }
14921 };
14922
14923 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
14924         .suite_name = "Negative AES GMAC Test Suite",
14925         .setup = negative_aes_gmac_testsuite_setup,
14926         .unit_test_cases = {
14927                 TEST_CASE_ST(ut_setup, ut_teardown,
14928                         authentication_verify_AES128_GMAC_fail_data_corrupt),
14929                 TEST_CASE_ST(ut_setup, ut_teardown,
14930                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
14931
14932                 TEST_CASES_END()
14933         }
14934 };
14935
14936 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
14937         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
14938         .setup = mixed_cipher_hash_testsuite_setup,
14939         .unit_test_cases = {
14940                 /** AUTH AES CMAC + CIPHER AES CTR */
14941                 TEST_CASE_ST(ut_setup, ut_teardown,
14942                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
14943                 TEST_CASE_ST(ut_setup, ut_teardown,
14944                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14945                 TEST_CASE_ST(ut_setup, ut_teardown,
14946                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14947                 TEST_CASE_ST(ut_setup, ut_teardown,
14948                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14949                 TEST_CASE_ST(ut_setup, ut_teardown,
14950                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
14951                 TEST_CASE_ST(ut_setup, ut_teardown,
14952                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
14953                 TEST_CASE_ST(ut_setup, ut_teardown,
14954                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
14955                 TEST_CASE_ST(ut_setup, ut_teardown,
14956                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
14957
14958                 /** AUTH ZUC + CIPHER SNOW3G */
14959                 TEST_CASE_ST(ut_setup, ut_teardown,
14960                         test_auth_zuc_cipher_snow_test_case_1),
14961                 TEST_CASE_ST(ut_setup, ut_teardown,
14962                         test_verify_auth_zuc_cipher_snow_test_case_1),
14963                 /** AUTH AES CMAC + CIPHER SNOW3G */
14964                 TEST_CASE_ST(ut_setup, ut_teardown,
14965                         test_auth_aes_cmac_cipher_snow_test_case_1),
14966                 TEST_CASE_ST(ut_setup, ut_teardown,
14967                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
14968                 /** AUTH ZUC + CIPHER AES CTR */
14969                 TEST_CASE_ST(ut_setup, ut_teardown,
14970                         test_auth_zuc_cipher_aes_ctr_test_case_1),
14971                 TEST_CASE_ST(ut_setup, ut_teardown,
14972                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
14973                 /** AUTH SNOW3G + CIPHER AES CTR */
14974                 TEST_CASE_ST(ut_setup, ut_teardown,
14975                         test_auth_snow_cipher_aes_ctr_test_case_1),
14976                 TEST_CASE_ST(ut_setup, ut_teardown,
14977                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
14978                 /** AUTH SNOW3G + CIPHER ZUC */
14979                 TEST_CASE_ST(ut_setup, ut_teardown,
14980                         test_auth_snow_cipher_zuc_test_case_1),
14981                 TEST_CASE_ST(ut_setup, ut_teardown,
14982                         test_verify_auth_snow_cipher_zuc_test_case_1),
14983                 /** AUTH AES CMAC + CIPHER ZUC */
14984                 TEST_CASE_ST(ut_setup, ut_teardown,
14985                         test_auth_aes_cmac_cipher_zuc_test_case_1),
14986                 TEST_CASE_ST(ut_setup, ut_teardown,
14987                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
14988
14989                 /** AUTH NULL + CIPHER SNOW3G */
14990                 TEST_CASE_ST(ut_setup, ut_teardown,
14991                         test_auth_null_cipher_snow_test_case_1),
14992                 TEST_CASE_ST(ut_setup, ut_teardown,
14993                         test_verify_auth_null_cipher_snow_test_case_1),
14994                 /** AUTH NULL + CIPHER ZUC */
14995                 TEST_CASE_ST(ut_setup, ut_teardown,
14996                         test_auth_null_cipher_zuc_test_case_1),
14997                 TEST_CASE_ST(ut_setup, ut_teardown,
14998                         test_verify_auth_null_cipher_zuc_test_case_1),
14999                 /** AUTH SNOW3G + CIPHER NULL */
15000                 TEST_CASE_ST(ut_setup, ut_teardown,
15001                         test_auth_snow_cipher_null_test_case_1),
15002                 TEST_CASE_ST(ut_setup, ut_teardown,
15003                         test_verify_auth_snow_cipher_null_test_case_1),
15004                 /** AUTH ZUC + CIPHER NULL */
15005                 TEST_CASE_ST(ut_setup, ut_teardown,
15006                         test_auth_zuc_cipher_null_test_case_1),
15007                 TEST_CASE_ST(ut_setup, ut_teardown,
15008                         test_verify_auth_zuc_cipher_null_test_case_1),
15009                 /** AUTH NULL + CIPHER AES CTR */
15010                 TEST_CASE_ST(ut_setup, ut_teardown,
15011                         test_auth_null_cipher_aes_ctr_test_case_1),
15012                 TEST_CASE_ST(ut_setup, ut_teardown,
15013                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15014                 /** AUTH AES CMAC + CIPHER NULL */
15015                 TEST_CASE_ST(ut_setup, ut_teardown,
15016                         test_auth_aes_cmac_cipher_null_test_case_1),
15017                 TEST_CASE_ST(ut_setup, ut_teardown,
15018                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15019                 TEST_CASES_END()
15020         }
15021 };
15022
15023 static int
15024 run_cryptodev_testsuite(const char *pmd_name)
15025 {
15026         uint8_t ret, j, i = 0, blk_start_idx = 0;
15027         const enum blockcipher_test_type blk_suites[] = {
15028                 BLKCIPHER_AES_CHAIN_TYPE,
15029                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15030                 BLKCIPHER_AES_DOCSIS_TYPE,
15031                 BLKCIPHER_3DES_CHAIN_TYPE,
15032                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15033                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15034                 BLKCIPHER_DES_DOCSIS_TYPE,
15035                 BLKCIPHER_AUTHONLY_TYPE};
15036         struct unit_test_suite *static_suites[] = {
15037                 &cryptodev_multi_session_testsuite,
15038                 &cryptodev_null_testsuite,
15039                 &cryptodev_aes_ccm_auth_testsuite,
15040                 &cryptodev_aes_gcm_auth_testsuite,
15041                 &cryptodev_aes_gmac_auth_testsuite,
15042                 &cryptodev_snow3g_testsuite,
15043                 &cryptodev_chacha20_poly1305_testsuite,
15044                 &cryptodev_zuc_testsuite,
15045                 &cryptodev_hmac_md5_auth_testsuite,
15046                 &cryptodev_kasumi_testsuite,
15047                 &cryptodev_esn_testsuite,
15048                 &cryptodev_negative_aes_gcm_testsuite,
15049                 &cryptodev_negative_aes_gmac_testsuite,
15050                 &cryptodev_mixed_cipher_hash_testsuite,
15051                 &cryptodev_negative_hmac_sha1_testsuite,
15052                 &cryptodev_gen_testsuite,
15053 #ifdef RTE_LIB_SECURITY
15054                 &ipsec_proto_testsuite,
15055                 &pdcp_proto_testsuite,
15056                 &docsis_proto_testsuite,
15057 #endif
15058                 &end_testsuite
15059         };
15060         static struct unit_test_suite ts = {
15061                 .suite_name = "Cryptodev Unit Test Suite",
15062                 .setup = testsuite_setup,
15063                 .teardown = testsuite_teardown,
15064                 .unit_test_cases = {TEST_CASES_END()}
15065         };
15066
15067         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15068
15069         if (gbl_driver_id == -1) {
15070                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15071                 return TEST_SKIPPED;
15072         }
15073
15074         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15075                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15076
15077         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15078         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15079         ret = unit_test_suite_runner(&ts);
15080
15081         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15082         free(ts.unit_test_suites);
15083         return ret;
15084 }
15085
15086 static int
15087 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15088 {
15089         struct rte_cryptodev_info dev_info;
15090         uint8_t i, nb_devs;
15091         int driver_id;
15092
15093         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15094         if (driver_id == -1) {
15095                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15096                 return TEST_SKIPPED;
15097         }
15098
15099         nb_devs = rte_cryptodev_count();
15100         if (nb_devs < 1) {
15101                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15102                 return TEST_SKIPPED;
15103         }
15104
15105         for (i = 0; i < nb_devs; i++) {
15106                 rte_cryptodev_info_get(i, &dev_info);
15107                 if (dev_info.driver_id == driver_id) {
15108                         if (!(dev_info.feature_flags & flag)) {
15109                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15110                                                 flag_name);
15111                                 return TEST_SKIPPED;
15112                         }
15113                         return 0; /* found */
15114                 }
15115         }
15116
15117         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15118         return TEST_SKIPPED;
15119 }
15120
15121 static int
15122 test_cryptodev_qat(void)
15123 {
15124         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15125 }
15126
15127 static int
15128 test_cryptodev_virtio(void)
15129 {
15130         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15131 }
15132
15133 static int
15134 test_cryptodev_aesni_mb(void)
15135 {
15136         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15137 }
15138
15139 static int
15140 test_cryptodev_cpu_aesni_mb(void)
15141 {
15142         int32_t rc;
15143         enum rte_security_session_action_type at = gbl_action_type;
15144         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15145         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15146         gbl_action_type = at;
15147         return rc;
15148 }
15149
15150 static int
15151 test_cryptodev_openssl(void)
15152 {
15153         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15154 }
15155
15156 static int
15157 test_cryptodev_aesni_gcm(void)
15158 {
15159         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15160 }
15161
15162 static int
15163 test_cryptodev_cpu_aesni_gcm(void)
15164 {
15165         int32_t rc;
15166         enum rte_security_session_action_type at = gbl_action_type;
15167         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15168         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15169         gbl_action_type = at;
15170         return rc;
15171 }
15172
15173 static int
15174 test_cryptodev_mlx5(void)
15175 {
15176         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15177 }
15178
15179 static int
15180 test_cryptodev_null(void)
15181 {
15182         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15183 }
15184
15185 static int
15186 test_cryptodev_sw_snow3g(void)
15187 {
15188         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15189 }
15190
15191 static int
15192 test_cryptodev_sw_kasumi(void)
15193 {
15194         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15195 }
15196
15197 static int
15198 test_cryptodev_sw_zuc(void)
15199 {
15200         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15201 }
15202
15203 static int
15204 test_cryptodev_armv8(void)
15205 {
15206         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15207 }
15208
15209 static int
15210 test_cryptodev_mrvl(void)
15211 {
15212         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15213 }
15214
15215 #ifdef RTE_CRYPTO_SCHEDULER
15216
15217 static int
15218 test_cryptodev_scheduler(void)
15219 {
15220         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15221         const enum blockcipher_test_type blk_suites[] = {
15222                 BLKCIPHER_AES_CHAIN_TYPE,
15223                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15224                 BLKCIPHER_AUTHONLY_TYPE
15225         };
15226         static struct unit_test_suite scheduler_multicore = {
15227                 .suite_name = "Scheduler Multicore Unit Test Suite",
15228                 .setup = scheduler_multicore_testsuite_setup,
15229                 .teardown = scheduler_mode_testsuite_teardown,
15230                 .unit_test_cases = {TEST_CASES_END()}
15231         };
15232         static struct unit_test_suite scheduler_round_robin = {
15233                 .suite_name = "Scheduler Round Robin Unit Test Suite",
15234                 .setup = scheduler_roundrobin_testsuite_setup,
15235                 .teardown = scheduler_mode_testsuite_teardown,
15236                 .unit_test_cases = {TEST_CASES_END()}
15237         };
15238         static struct unit_test_suite scheduler_failover = {
15239                 .suite_name = "Scheduler Failover Unit Test Suite",
15240                 .setup = scheduler_failover_testsuite_setup,
15241                 .teardown = scheduler_mode_testsuite_teardown,
15242                 .unit_test_cases = {TEST_CASES_END()}
15243         };
15244         static struct unit_test_suite scheduler_pkt_size_distr = {
15245                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15246                 .setup = scheduler_pkt_size_distr_testsuite_setup,
15247                 .teardown = scheduler_mode_testsuite_teardown,
15248                 .unit_test_cases = {TEST_CASES_END()}
15249         };
15250         struct unit_test_suite *sched_mode_suites[] = {
15251                 &scheduler_multicore,
15252                 &scheduler_round_robin,
15253                 &scheduler_failover,
15254                 &scheduler_pkt_size_distr
15255         };
15256         static struct unit_test_suite scheduler_config = {
15257                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15258                 .unit_test_cases = {
15259                         TEST_CASE(test_scheduler_attach_worker_op),
15260                         TEST_CASE(test_scheduler_mode_multicore_op),
15261                         TEST_CASE(test_scheduler_mode_roundrobin_op),
15262                         TEST_CASE(test_scheduler_mode_failover_op),
15263                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15264                         TEST_CASE(test_scheduler_detach_worker_op),
15265
15266                         TEST_CASES_END() /**< NULL terminate array */
15267                 }
15268         };
15269         struct unit_test_suite *static_suites[] = {
15270                 &scheduler_config,
15271                 &end_testsuite
15272         };
15273         static struct unit_test_suite ts = {
15274                 .suite_name = "Scheduler Unit Test Suite",
15275                 .setup = scheduler_testsuite_setup,
15276                 .teardown = testsuite_teardown,
15277                 .unit_test_cases = {TEST_CASES_END()}
15278         };
15279
15280         gbl_driver_id = rte_cryptodev_driver_id_get(
15281                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15282
15283         if (gbl_driver_id == -1) {
15284                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15285                 return TEST_SKIPPED;
15286         }
15287
15288         if (rte_cryptodev_driver_id_get(
15289                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15290                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15291                 return TEST_SKIPPED;
15292         }
15293
15294         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15295                 uint8_t blk_i = 0;
15296                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15297                                 (struct unit_test_suite *) *
15298                                 (RTE_DIM(blk_suites) + 1));
15299                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15300                                 blk_suites, RTE_DIM(blk_suites));
15301                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15302         }
15303
15304         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15305                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15306         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15307                         RTE_DIM(sched_mode_suites));
15308         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15309         ret = unit_test_suite_runner(&ts);
15310
15311         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15312                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15313                                 (*sched_mode_suites[sched_i]),
15314                                 RTE_DIM(blk_suites));
15315                 free(sched_mode_suites[sched_i]->unit_test_suites);
15316         }
15317         free(ts.unit_test_suites);
15318         return ret;
15319 }
15320
15321 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15322
15323 #endif
15324
15325 static int
15326 test_cryptodev_dpaa2_sec(void)
15327 {
15328         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15329 }
15330
15331 static int
15332 test_cryptodev_dpaa_sec(void)
15333 {
15334         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15335 }
15336
15337 static int
15338 test_cryptodev_ccp(void)
15339 {
15340         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15341 }
15342
15343 static int
15344 test_cryptodev_octeontx(void)
15345 {
15346         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15347 }
15348
15349 static int
15350 test_cryptodev_octeontx2(void)
15351 {
15352         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
15353 }
15354
15355 static int
15356 test_cryptodev_caam_jr(void)
15357 {
15358         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15359 }
15360
15361 static int
15362 test_cryptodev_nitrox(void)
15363 {
15364         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15365 }
15366
15367 static int
15368 test_cryptodev_bcmfs(void)
15369 {
15370         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15371 }
15372
15373 static int
15374 test_cryptodev_qat_raw_api(void)
15375 {
15376         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15377         int ret;
15378
15379         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15380                         "RAW API");
15381         if (ret)
15382                 return ret;
15383
15384         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15385         ret = run_cryptodev_testsuite(pmd_name);
15386         global_api_test_type = CRYPTODEV_API_TEST;
15387
15388         return ret;
15389 }
15390
15391 static int
15392 test_cryptodev_cn9k(void)
15393 {
15394         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15395 }
15396
15397 static int
15398 test_cryptodev_cn10k(void)
15399 {
15400         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15401 }
15402
15403 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15404                 test_cryptodev_qat_raw_api);
15405 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15406 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15407 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15408         test_cryptodev_cpu_aesni_mb);
15409 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
15410 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
15411 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
15412         test_cryptodev_cpu_aesni_gcm);
15413 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
15414 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
15415 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
15416 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
15417 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
15418 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
15419 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
15420 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
15421 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
15422 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
15423 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
15424 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
15425 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
15426 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
15427 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
15428 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
15429 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
15430 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);