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_cryptodev_pmd.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_pdcp_test_vectors.h"
  46 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  47 #include "test_cryptodev_security_pdcp_test_func.h"
  48 #include "test_cryptodev_security_docsis_test_vectors.h"
  49
  50 #define SDAP_DISABLED   0
  51 #define SDAP_ENABLED    1
  52 #endif
  53
  54 #define VDEV_ARGS_SIZE 100
  55 #define MAX_NB_SESSIONS 4
  56
  57 #define MAX_DRV_SERVICE_CTX_SIZE 256
  58
  59 #define MAX_RAW_DEQUEUE_COUNT   65535
  60
  61 #define IN_PLACE 0
  62 #define OUT_OF_PLACE 1
  63
  64 #ifndef ARRAY_SIZE
  65 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  66 #endif
  67
  68 static int gbl_driver_id;
  69
  70 static enum rte_security_session_action_type gbl_action_type =
  71         RTE_SECURITY_ACTION_TYPE_NONE;
  72
  73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  74
  75 struct crypto_testsuite_params {
  76         struct rte_mempool *mbuf_pool;
  77         struct rte_mempool *large_mbuf_pool;
  78         struct rte_mempool *op_mpool;
  79         struct rte_mempool *session_mpool;
  80         struct rte_mempool *session_priv_mpool;
  81         struct rte_cryptodev_config conf;
  82         struct rte_cryptodev_qp_conf qp_conf;
  83
  84         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  85         uint8_t valid_dev_count;
  86 };
  87
  88 struct crypto_unittest_params {
  89         struct rte_crypto_sym_xform cipher_xform;
  90         struct rte_crypto_sym_xform auth_xform;
  91         struct rte_crypto_sym_xform aead_xform;
  92 #ifdef RTE_LIB_SECURITY
  93         struct rte_security_docsis_xform docsis_xform;
  94 #endif
  95
  96         union {
  97                 struct rte_cryptodev_sym_session *sess;
  98 #ifdef RTE_LIB_SECURITY
  99                 struct rte_security_session *sec_session;
 100 #endif
 101         };
 102 #ifdef RTE_LIB_SECURITY
 103         enum rte_security_session_action_type type;
 104 #endif
 105         struct rte_crypto_op *op;
 106
 107         struct rte_mbuf *obuf, *ibuf;
 108
 109         uint8_t *digest;
 110 };
 111
 112 #define ALIGN_POW2_ROUNDUP(num, align) \
 113         (((num) + (align) - 1) & ~((align) - 1))
 114
 115 /*
 116  * Forward declarations.
 117  */
 118 static int
 119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 120                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 121                 uint8_t *hmac_key);
 122
 123 static int
 124 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 125                 struct crypto_unittest_params *ut_params,
 126                 struct crypto_testsuite_params *ts_param,
 127                 const uint8_t *cipher,
 128                 const uint8_t *digest,
 129                 const uint8_t *iv);
 130
 131 static struct rte_mbuf *
 132 setup_test_string(struct rte_mempool *mpool,
 133                 const char *string, size_t len, uint8_t blocksize)
 134 {
 135         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 136         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 137
 138         memset(m->buf_addr, 0, m->buf_len);
 139         if (m) {
 140                 char *dst = rte_pktmbuf_append(m, t_len);
 141
 142                 if (!dst) {
 143                         rte_pktmbuf_free(m);
 144                         return NULL;
 145                 }
 146                 if (string != NULL)
 147                         rte_memcpy(dst, string, t_len);
 148                 else
 149                         memset(dst, 0, t_len);
 150         }
 151
 152         return m;
 153 }
 154
 155 /* Get number of bytes in X bits (rounding up) */
 156 static uint32_t
 157 ceil_byte_length(uint32_t num_bits)
 158 {
 159         if (num_bits % 8)
 160                 return ((num_bits >> 3) + 1);
 161         else
 162                 return (num_bits >> 3);
 163 }
 164
 165 static uint32_t
 166 get_raw_dp_dequeue_count(void *user_data __rte_unused)
 167 {
 168         return 1;
 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                         get_raw_dp_dequeue_count, 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 static struct crypto_unittest_params unittest_params;
 492
 493 static int
 494 testsuite_setup(void)
 495 {
 496         struct crypto_testsuite_params *ts_params = &testsuite_params;
 497         struct rte_cryptodev_info info;
 498         uint32_t i = 0, nb_devs, dev_id;
 499         int ret;
 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         /* Create an AESNI MB device if required */
 546         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 547                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
 548                 nb_devs = rte_cryptodev_device_count_by_driver(
 549                                 rte_cryptodev_driver_id_get(
 550                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
 551                 if (nb_devs < 1) {
 552                         ret = rte_vdev_init(
 553                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 554
 555                         TEST_ASSERT(ret == 0,
 556                                 "Failed to create instance of"
 557                                 " pmd : %s",
 558                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 559                 }
 560         }
 561
 562         /* Create an AESNI GCM device if required */
 563         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 564                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
 565                 nb_devs = rte_cryptodev_device_count_by_driver(
 566                                 rte_cryptodev_driver_id_get(
 567                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
 568                 if (nb_devs < 1) {
 569                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 570                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 571                                 "Failed to create instance of"
 572                                 " pmd : %s",
 573                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 574                 }
 575         }
 576
 577         /* Create a SNOW 3G device if required */
 578         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 579                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
 580                 nb_devs = rte_cryptodev_device_count_by_driver(
 581                                 rte_cryptodev_driver_id_get(
 582                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
 583                 if (nb_devs < 1) {
 584                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 585                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 586                                 "Failed to create instance of"
 587                                 " pmd : %s",
 588                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 589                 }
 590         }
 591
 592         /* Create a KASUMI device if required */
 593         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 594                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
 595                 nb_devs = rte_cryptodev_device_count_by_driver(
 596                                 rte_cryptodev_driver_id_get(
 597                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
 598                 if (nb_devs < 1) {
 599                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 600                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 601                                 "Failed to create instance of"
 602                                 " pmd : %s",
 603                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 604                 }
 605         }
 606
 607         /* Create a ZUC device if required */
 608         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 609                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
 610                 nb_devs = rte_cryptodev_device_count_by_driver(
 611                                 rte_cryptodev_driver_id_get(
 612                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
 613                 if (nb_devs < 1) {
 614                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 615                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 616                                 "Failed to create instance of"
 617                                 " pmd : %s",
 618                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 619                 }
 620         }
 621
 622         /* Create a NULL device if required */
 623         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 624                         RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
 625                 nb_devs = rte_cryptodev_device_count_by_driver(
 626                                 rte_cryptodev_driver_id_get(
 627                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
 628                 if (nb_devs < 1) {
 629                         ret = rte_vdev_init(
 630                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 631
 632                         TEST_ASSERT(ret == 0,
 633                                 "Failed to create instance of"
 634                                 " pmd : %s",
 635                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 636                 }
 637         }
 638
 639         /* Create an OPENSSL device if required */
 640         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 641                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 642                 nb_devs = rte_cryptodev_device_count_by_driver(
 643                                 rte_cryptodev_driver_id_get(
 644                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 645                 if (nb_devs < 1) {
 646                         ret = rte_vdev_init(
 647                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 648                                 NULL);
 649
 650                         TEST_ASSERT(ret == 0, "Failed to create "
 651                                 "instance of pmd : %s",
 652                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 653                 }
 654         }
 655
 656         /* Create a ARMv8 device if required */
 657         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 658                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
 659                 nb_devs = rte_cryptodev_device_count_by_driver(
 660                                 rte_cryptodev_driver_id_get(
 661                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
 662                 if (nb_devs < 1) {
 663                         ret = rte_vdev_init(
 664                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 665                                 NULL);
 666
 667                         TEST_ASSERT(ret == 0, "Failed to create "
 668                                 "instance of pmd : %s",
 669                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 670                 }
 671         }
 672
 673         /* Create a MVSAM device if required */
 674         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 675                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
 676                 nb_devs = rte_cryptodev_device_count_by_driver(
 677                                 rte_cryptodev_driver_id_get(
 678                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
 679                 if (nb_devs < 1) {
 680                         ret = rte_vdev_init(
 681                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
 682                                 NULL);
 683
 684                         TEST_ASSERT(ret == 0, "Failed to create "
 685                                 "instance of pmd : %s",
 686                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
 687                 }
 688         }
 689
 690         /* Create an CCP device if required */
 691         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 692                         RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
 693                 nb_devs = rte_cryptodev_device_count_by_driver(
 694                                 rte_cryptodev_driver_id_get(
 695                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
 696                 if (nb_devs < 1) {
 697                         ret = rte_vdev_init(
 698                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
 699                                 NULL);
 700
 701                         TEST_ASSERT(ret == 0, "Failed to create "
 702                                 "instance of pmd : %s",
 703                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
 704                 }
 705         }
 706
 707 #ifdef RTE_CRYPTO_SCHEDULER
 708         char vdev_args[VDEV_ARGS_SIZE] = {""};
 709         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
 710                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
 711         uint16_t worker_core_count = 0;
 712         uint16_t socket_id = 0;
 713
 714         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 715                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 716
 717                 /* Identify the Worker Cores
 718                  * Use 2 worker cores for the device args
 719                  */
 720                 RTE_LCORE_FOREACH_WORKER(i) {
 721                         if (worker_core_count > 1)
 722                                 break;
 723                         snprintf(vdev_args, sizeof(vdev_args),
 724                                         "%s%d", temp_str, i);
 725                         strcpy(temp_str, vdev_args);
 726                         strlcat(temp_str, ";", sizeof(temp_str));
 727                         worker_core_count++;
 728                         socket_id = rte_lcore_to_socket_id(i);
 729                 }
 730                 if (worker_core_count != 2) {
 731                         RTE_LOG(ERR, USER1,
 732                                 "Cryptodev scheduler test require at least "
 733                                 "two worker cores to run. "
 734                                 "Please use the correct coremask.\n");
 735                         return TEST_FAILED;
 736                 }
 737                 strcpy(temp_str, vdev_args);
 738                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
 739                                 temp_str, socket_id);
 740                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 741                 nb_devs = rte_cryptodev_device_count_by_driver(
 742                                 rte_cryptodev_driver_id_get(
 743                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 744                 if (nb_devs < 1) {
 745                         ret = rte_vdev_init(
 746                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 747                                         vdev_args);
 748                         TEST_ASSERT(ret == 0,
 749                                 "Failed to create instance %u of"
 750                                 " pmd : %s",
 751                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 752                 }
 753         }
 754 #endif /* RTE_CRYPTO_SCHEDULER */
 755
 756         nb_devs = rte_cryptodev_count();
 757         if (nb_devs < 1) {
 758                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 759                 return TEST_SKIPPED;
 760         }
 761
 762         /* Create list of valid crypto devs */
 763         for (i = 0; i < nb_devs; i++) {
 764                 rte_cryptodev_info_get(i, &info);
 765                 if (info.driver_id == gbl_driver_id)
 766                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 767         }
 768
 769         if (ts_params->valid_dev_count < 1)
 770                 return TEST_FAILED;
 771
 772         /* Set up all the qps on the first of the valid devices found */
 773
 774         dev_id = ts_params->valid_devs[0];
 775
 776         rte_cryptodev_info_get(dev_id, &info);
 777
 778         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 779         ts_params->conf.socket_id = SOCKET_ID_ANY;
 780         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 781
 782         unsigned int session_size =
 783                 rte_cryptodev_sym_get_private_session_size(dev_id);
 784
 785 #ifdef RTE_LIB_SECURITY
 786         unsigned int security_session_size = rte_security_session_get_size(
 787                         rte_cryptodev_get_sec_ctx(dev_id));
 788
 789         if (session_size < security_session_size)
 790                 session_size = security_session_size;
 791 #endif
 792         /*
 793          * Create mempool with maximum number of sessions.
 794          */
 795         if (info.sym.max_nb_sessions != 0 &&
 796                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 797                 RTE_LOG(ERR, USER1, "Device does not support "
 798                                 "at least %u sessions\n",
 799                                 MAX_NB_SESSIONS);
 800                 return TEST_FAILED;
 801         }
 802
 803         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 804                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 805                         SOCKET_ID_ANY);
 806         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 807                         "session mempool allocation failed");
 808
 809         ts_params->session_priv_mpool = rte_mempool_create(
 810                         "test_sess_mp_priv",
 811                         MAX_NB_SESSIONS,
 812                         session_size,
 813                         0, 0, NULL, NULL, NULL,
 814                         NULL, SOCKET_ID_ANY,
 815                         0);
 816         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 817                         "session mempool allocation failed");
 818
 819
 820
 821         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 822                         &ts_params->conf),
 823                         "Failed to configure cryptodev %u with %u qps",
 824                         dev_id, ts_params->conf.nb_queue_pairs);
 825
 826         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 827         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 828         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 829
 830         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 831                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 832                         dev_id, qp_id, &ts_params->qp_conf,
 833                         rte_cryptodev_socket_id(dev_id)),
 834                         "Failed to setup queue pair %u on cryptodev %u",
 835                         qp_id, dev_id);
 836         }
 837
 838         return TEST_SUCCESS;
 839 }
 840
 841 static void
 842 testsuite_teardown(void)
 843 {
 844         struct crypto_testsuite_params *ts_params = &testsuite_params;
 845
 846         if (ts_params->mbuf_pool != NULL) {
 847                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 848                 rte_mempool_avail_count(ts_params->mbuf_pool));
 849         }
 850
 851         if (ts_params->op_mpool != NULL) {
 852                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 853                 rte_mempool_avail_count(ts_params->op_mpool));
 854         }
 855
 856         /* Free session mempools */
 857         if (ts_params->session_priv_mpool != NULL) {
 858                 rte_mempool_free(ts_params->session_priv_mpool);
 859                 ts_params->session_priv_mpool = NULL;
 860         }
 861
 862         if (ts_params->session_mpool != NULL) {
 863                 rte_mempool_free(ts_params->session_mpool);
 864                 ts_params->session_mpool = NULL;
 865         }
 866 }
 867
 868 static int
 869 dev_configure_and_start(uint64_t ff_disable)
 870 {
 871         struct crypto_testsuite_params *ts_params = &testsuite_params;
 872         struct crypto_unittest_params *ut_params = &unittest_params;
 873
 874         uint16_t qp_id;
 875
 876         /* Clear unit test parameters before running test */
 877         memset(ut_params, 0, sizeof(*ut_params));
 878
 879         /* Reconfigure device to default parameters */
 880         ts_params->conf.socket_id = SOCKET_ID_ANY;
 881         ts_params->conf.ff_disable = ff_disable;
 882         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 883         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 884         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 885
 886         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 887                         &ts_params->conf),
 888                         "Failed to configure cryptodev %u",
 889                         ts_params->valid_devs[0]);
 890
 891         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 892                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 893                         ts_params->valid_devs[0], qp_id,
 894                         &ts_params->qp_conf,
 895                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 896                         "Failed to setup queue pair %u on cryptodev %u",
 897                         qp_id, ts_params->valid_devs[0]);
 898         }
 899
 900
 901         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 902
 903         /* Start the device */
 904         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 905                         "Failed to start cryptodev %u",
 906                         ts_params->valid_devs[0]);
 907
 908         return TEST_SUCCESS;
 909 }
 910
 911 static int
 912 ut_setup(void)
 913 {
 914         /* Configure and start the device with security feature disabled */
 915         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
 916 }
 917
 918 static int
 919 ut_setup_security(void)
 920 {
 921         /* Configure and start the device with no features disabled */
 922         return dev_configure_and_start(0);
 923 }
 924
 925 static void
 926 ut_teardown(void)
 927 {
 928         struct crypto_testsuite_params *ts_params = &testsuite_params;
 929         struct crypto_unittest_params *ut_params = &unittest_params;
 930         struct rte_cryptodev_stats stats;
 931
 932         /* free crypto session structure */
 933 #ifdef RTE_LIB_SECURITY
 934         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
 935                 if (ut_params->sec_session) {
 936                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
 937                                                 (ts_params->valid_devs[0]),
 938                                                 ut_params->sec_session);
 939                         ut_params->sec_session = NULL;
 940                 }
 941         } else
 942 #endif
 943         {
 944                 if (ut_params->sess) {
 945                         rte_cryptodev_sym_session_clear(
 946                                         ts_params->valid_devs[0],
 947                                         ut_params->sess);
 948                         rte_cryptodev_sym_session_free(ut_params->sess);
 949                         ut_params->sess = NULL;
 950                 }
 951         }
 952
 953         /* free crypto operation structure */
 954         if (ut_params->op)
 955                 rte_crypto_op_free(ut_params->op);
 956
 957         /*
 958          * free mbuf - both obuf and ibuf are usually the same,
 959          * so check if they point at the same address is necessary,
 960          * to avoid freeing the mbuf twice.
 961          */
 962         if (ut_params->obuf) {
 963                 rte_pktmbuf_free(ut_params->obuf);
 964                 if (ut_params->ibuf == ut_params->obuf)
 965                         ut_params->ibuf = 0;
 966                 ut_params->obuf = 0;
 967         }
 968         if (ut_params->ibuf) {
 969                 rte_pktmbuf_free(ut_params->ibuf);
 970                 ut_params->ibuf = 0;
 971         }
 972
 973         if (ts_params->mbuf_pool != NULL)
 974                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 975                         rte_mempool_avail_count(ts_params->mbuf_pool));
 976
 977         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 978
 979         /* Stop the device */
 980         rte_cryptodev_stop(ts_params->valid_devs[0]);
 981 }
 982
 983 static int
 984 test_device_configure_invalid_dev_id(void)
 985 {
 986         struct crypto_testsuite_params *ts_params = &testsuite_params;
 987         uint16_t dev_id, num_devs = 0;
 988
 989         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 990                         "Need at least %d devices for test", 1);
 991
 992         /* valid dev_id values */
 993         dev_id = ts_params->valid_devs[0];
 994
 995         /* Stop the device in case it's started so it can be configured */
 996         rte_cryptodev_stop(dev_id);
 997
 998         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 999                         "Failed test for rte_cryptodev_configure: "
1000                         "invalid dev_num %u", dev_id);
1001
1002         /* invalid dev_id values */
1003         dev_id = num_devs;
1004
1005         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1006                         "Failed test for rte_cryptodev_configure: "
1007                         "invalid dev_num %u", dev_id);
1008
1009         dev_id = 0xff;
1010
1011         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1012                         "Failed test for rte_cryptodev_configure:"
1013                         "invalid dev_num %u", dev_id);
1014
1015         return TEST_SUCCESS;
1016 }
1017
1018 static int
1019 test_device_configure_invalid_queue_pair_ids(void)
1020 {
1021         struct crypto_testsuite_params *ts_params = &testsuite_params;
1022         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1023
1024         /* Stop the device in case it's started so it can be configured */
1025         rte_cryptodev_stop(ts_params->valid_devs[0]);
1026
1027         /* valid - max value queue pairs */
1028         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1029
1030         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1031                         &ts_params->conf),
1032                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1033                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1034
1035         /* valid - one queue pairs */
1036         ts_params->conf.nb_queue_pairs = 1;
1037
1038         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1039                         &ts_params->conf),
1040                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1041                         ts_params->valid_devs[0],
1042                         ts_params->conf.nb_queue_pairs);
1043
1044
1045         /* invalid - zero queue pairs */
1046         ts_params->conf.nb_queue_pairs = 0;
1047
1048         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1049                         &ts_params->conf),
1050                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1051                         " invalid qps: %u",
1052                         ts_params->valid_devs[0],
1053                         ts_params->conf.nb_queue_pairs);
1054
1055
1056         /* invalid - max value supported by field queue pairs */
1057         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1058
1059         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1060                         &ts_params->conf),
1061                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1062                         " invalid qps: %u",
1063                         ts_params->valid_devs[0],
1064                         ts_params->conf.nb_queue_pairs);
1065
1066
1067         /* invalid - max value + 1 queue pairs */
1068         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1069
1070         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1071                         &ts_params->conf),
1072                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1073                         " invalid qps: %u",
1074                         ts_params->valid_devs[0],
1075                         ts_params->conf.nb_queue_pairs);
1076
1077         /* revert to original testsuite value */
1078         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1079
1080         return TEST_SUCCESS;
1081 }
1082
1083 static int
1084 test_queue_pair_descriptor_setup(void)
1085 {
1086         struct crypto_testsuite_params *ts_params = &testsuite_params;
1087         struct rte_cryptodev_qp_conf qp_conf = {
1088                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1089         };
1090         uint16_t qp_id;
1091
1092         /* Stop the device in case it's started so it can be configured */
1093         rte_cryptodev_stop(ts_params->valid_devs[0]);
1094
1095         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1096                         &ts_params->conf),
1097                         "Failed to configure cryptodev %u",
1098                         ts_params->valid_devs[0]);
1099
1100         /*
1101          * Test various ring sizes on this device. memzones can't be
1102          * freed so are re-used if ring is released and re-created.
1103          */
1104         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1105         qp_conf.mp_session = ts_params->session_mpool;
1106         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1107
1108         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1109                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1110                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1111                                 rte_cryptodev_socket_id(
1112                                                 ts_params->valid_devs[0])),
1113                                 "Failed test for "
1114                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1115                                 "%u on qp %u on cryptodev %u",
1116                                 qp_conf.nb_descriptors, qp_id,
1117                                 ts_params->valid_devs[0]);
1118         }
1119
1120         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1121
1122         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1123                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1124                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1125                                 rte_cryptodev_socket_id(
1126                                                 ts_params->valid_devs[0])),
1127                                 "Failed test for"
1128                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1129                                 " %u on qp %u on cryptodev %u",
1130                                 qp_conf.nb_descriptors, qp_id,
1131                                 ts_params->valid_devs[0]);
1132         }
1133
1134         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1135
1136         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1137                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1138                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1139                                 rte_cryptodev_socket_id(
1140                                                 ts_params->valid_devs[0])),
1141                                 "Failed test for "
1142                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1143                                 " %u on qp %u on cryptodev %u",
1144                                 qp_conf.nb_descriptors, qp_id,
1145                                 ts_params->valid_devs[0]);
1146         }
1147
1148         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1149
1150         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1151                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1152                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1153                                 rte_cryptodev_socket_id(
1154                                                 ts_params->valid_devs[0])),
1155                                 "Failed test for"
1156                                 " rte_cryptodev_queue_pair_setup:"
1157                                 "num_inflights %u on qp %u on cryptodev %u",
1158                                 qp_conf.nb_descriptors, qp_id,
1159                                 ts_params->valid_devs[0]);
1160         }
1161
1162         /* test invalid queue pair id */
1163         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1164
1165         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1166
1167         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1168                         ts_params->valid_devs[0],
1169                         qp_id, &qp_conf,
1170                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1171                         "Failed test for rte_cryptodev_queue_pair_setup:"
1172                         "invalid qp %u on cryptodev %u",
1173                         qp_id, ts_params->valid_devs[0]);
1174
1175         qp_id = 0xffff; /*invalid*/
1176
1177         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1178                         ts_params->valid_devs[0],
1179                         qp_id, &qp_conf,
1180                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1181                         "Failed test for rte_cryptodev_queue_pair_setup:"
1182                         "invalid qp %u on cryptodev %u",
1183                         qp_id, ts_params->valid_devs[0]);
1184
1185         return TEST_SUCCESS;
1186 }
1187
1188 /* ***** Plaintext data for tests ***** */
1189
1190 const char catch_22_quote_1[] =
1191                 "There was only one catch and that was Catch-22, which "
1192                 "specified that a concern for one's safety in the face of "
1193                 "dangers that were real and immediate was the process of a "
1194                 "rational mind. Orr was crazy and could be grounded. All he "
1195                 "had to do was ask; and as soon as he did, he would no longer "
1196                 "be crazy and would have to fly more missions. Orr would be "
1197                 "crazy to fly more missions and sane if he didn't, but if he "
1198                 "was sane he had to fly them. If he flew them he was crazy "
1199                 "and didn't have to; but if he didn't want to he was sane and "
1200                 "had to. Yossarian was moved very deeply by the absolute "
1201                 "simplicity of this clause of Catch-22 and let out a "
1202                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1203                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1204
1205 const char catch_22_quote[] =
1206                 "What a lousy earth! He wondered how many people were "
1207                 "destitute that same night even in his own prosperous country, "
1208                 "how many homes were shanties, how many husbands were drunk "
1209                 "and wives socked, and how many children were bullied, abused, "
1210                 "or abandoned. How many families hungered for food they could "
1211                 "not afford to buy? How many hearts were broken? How many "
1212                 "suicides would take place that same night, how many people "
1213                 "would go insane? How many cockroaches and landlords would "
1214                 "triumph? How many winners were losers, successes failures, "
1215                 "and rich men poor men? How many wise guys were stupid? How "
1216                 "many happy endings were unhappy endings? How many honest men "
1217                 "were liars, brave men cowards, loyal men traitors, how many "
1218                 "sainted men were corrupt, how many people in positions of "
1219                 "trust had sold their souls to bodyguards, how many had never "
1220                 "had souls? How many straight-and-narrow paths were crooked "
1221                 "paths? How many best families were worst families and how "
1222                 "many good people were bad people? When you added them all up "
1223                 "and then subtracted, you might be left with only the children, "
1224                 "and perhaps with Albert Einstein and an old violinist or "
1225                 "sculptor somewhere.";
1226
1227 #define QUOTE_480_BYTES         (480)
1228 #define QUOTE_512_BYTES         (512)
1229 #define QUOTE_768_BYTES         (768)
1230 #define QUOTE_1024_BYTES        (1024)
1231
1232
1233
1234 /* ***** SHA1 Hash Tests ***** */
1235
1236 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1237
1238 static uint8_t hmac_sha1_key[] = {
1239         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1240         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1241         0xDE, 0xF4, 0xDE, 0xAD };
1242
1243 /* ***** SHA224 Hash Tests ***** */
1244
1245 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1246
1247
1248 /* ***** AES-CBC Cipher Tests ***** */
1249
1250 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1251 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1252
1253 static uint8_t aes_cbc_key[] = {
1254         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1255         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1256
1257 static uint8_t aes_cbc_iv[] = {
1258         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1259         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1260
1261
1262 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1263
1264 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1265         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1266         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1267         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1268         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1269         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1270         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1271         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1272         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1273         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1274         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1275         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1276         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1277         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1278         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1279         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1280         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1281         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1282         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1283         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1284         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1285         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1286         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1287         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1288         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1289         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1290         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1291         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1292         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1293         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1294         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1295         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1296         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1297         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1298         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1299         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1300         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1301         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1302         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1303         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1304         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1305         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1306         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1307         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1308         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1309         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1310         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1311         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1312         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1313         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1314         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1315         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1316         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1317         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1318         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1319         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1320         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1321         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1322         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1323         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1324         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1325         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1326         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1327         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1328         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1329 };
1330
1331 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1332         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1333         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1334         0x18, 0x8c, 0x1d, 0x32
1335 };
1336
1337
1338 /* Multisession Vector context Test */
1339 /*Begin Session 0 */
1340 static uint8_t ms_aes_cbc_key0[] = {
1341         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1342         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1343 };
1344
1345 static uint8_t ms_aes_cbc_iv0[] = {
1346         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1347         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1348 };
1349
1350 static const uint8_t ms_aes_cbc_cipher0[] = {
1351                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1352                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1353                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1354                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1355                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1356                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1357                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1358                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1359                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1360                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1361                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1362                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1363                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1364                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1365                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1366                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1367                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1368                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1369                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1370                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1371                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1372                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1373                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1374                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1375                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1376                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1377                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1378                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1379                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1380                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1381                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1382                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1383                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1384                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1385                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1386                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1387                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1388                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1389                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1390                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1391                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1392                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1393                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1394                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1395                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1396                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1397                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1398                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1399                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1400                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1401                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1402                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1403                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1404                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1405                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1406                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1407                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1408                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1409                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1410                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1411                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1412                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1413                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1414                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1415 };
1416
1417
1418 static  uint8_t ms_hmac_key0[] = {
1419                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1420                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1421                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1422                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1423                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1424                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1425                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1426                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1427 };
1428
1429 static const uint8_t ms_hmac_digest0[] = {
1430                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1431                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1432                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1433                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1434                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1435                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1436                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1437                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1438                 };
1439
1440 /* End Session 0 */
1441 /* Begin session 1 */
1442
1443 static  uint8_t ms_aes_cbc_key1[] = {
1444                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1445                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1446 };
1447
1448 static  uint8_t ms_aes_cbc_iv1[] = {
1449         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1450         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1451 };
1452
1453 static const uint8_t ms_aes_cbc_cipher1[] = {
1454                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1455                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1456                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1457                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1458                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1459                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1460                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1461                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1462                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1463                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1464                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1465                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1466                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1467                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1468                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1469                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1470                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1471                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1472                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1473                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1474                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1475                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1476                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1477                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1478                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1479                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1480                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1481                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1482                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1483                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1484                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1485                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1486                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1487                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1488                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1489                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1490                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1491                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1492                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1493                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1494                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1495                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1496                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1497                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1498                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1499                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1500                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1501                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1502                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1503                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1504                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1505                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1506                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1507                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1508                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1509                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1510                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1511                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1512                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1513                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1514                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1515                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1516                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1517                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1518
1519 };
1520
1521 static uint8_t ms_hmac_key1[] = {
1522                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1523                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1524                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1525                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1526                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1527                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1528                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1529                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1530 };
1531
1532 static const uint8_t ms_hmac_digest1[] = {
1533                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1534                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1535                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1536                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1537                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1538                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1539                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1540                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1541 };
1542 /* End Session 1  */
1543 /* Begin Session 2 */
1544 static  uint8_t ms_aes_cbc_key2[] = {
1545                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1546                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1547 };
1548
1549 static  uint8_t ms_aes_cbc_iv2[] = {
1550                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1551                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1552 };
1553
1554 static const uint8_t ms_aes_cbc_cipher2[] = {
1555                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1556                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1557                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1558                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1559                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1560                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1561                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1562                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1563                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1564                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1565                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1566                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1567                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1568                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1569                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1570                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1571                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1572                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1573                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1574                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1575                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1576                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1577                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1578                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1579                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1580                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1581                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1582                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1583                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1584                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1585                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1586                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1587                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1588                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1589                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1590                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1591                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1592                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1593                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1594                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1595                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1596                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1597                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1598                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1599                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1600                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1601                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1602                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1603                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1604                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1605                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1606                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1607                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1608                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1609                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1610                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1611                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1612                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1613                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1614                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1615                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1616                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1617                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1618                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1619 };
1620
1621 static  uint8_t ms_hmac_key2[] = {
1622                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1623                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1624                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1625                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1626                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1627                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1628                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1629                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1630 };
1631
1632 static const uint8_t ms_hmac_digest2[] = {
1633                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1634                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1635                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1636                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1637                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1638                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1639                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1640                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1641 };
1642
1643 /* End Session 2 */
1644
1645
1646 static int
1647 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1648 {
1649         struct crypto_testsuite_params *ts_params = &testsuite_params;
1650         struct crypto_unittest_params *ut_params = &unittest_params;
1651
1652         /* Verify the capabilities */
1653         struct rte_cryptodev_sym_capability_idx cap_idx;
1654         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1655         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
1656         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1657                         &cap_idx) == NULL)
1658                 return -ENOTSUP;
1659         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1660         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
1661         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1662                         &cap_idx) == NULL)
1663                 return -ENOTSUP;
1664
1665         /* Generate test mbuf data and space for digest */
1666         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1667                         catch_22_quote, QUOTE_512_BYTES, 0);
1668
1669         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1670                         DIGEST_BYTE_LENGTH_SHA1);
1671         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1672
1673         /* Setup Cipher Parameters */
1674         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1675         ut_params->cipher_xform.next = &ut_params->auth_xform;
1676
1677         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1678         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1679         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1680         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1681         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1682         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1683
1684         /* Setup HMAC Parameters */
1685         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1686
1687         ut_params->auth_xform.next = NULL;
1688
1689         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1690         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1691         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1692         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1693         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1694
1695         ut_params->sess = rte_cryptodev_sym_session_create(
1696                         ts_params->session_mpool);
1697
1698         /* Create crypto session*/
1699         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1700                         ut_params->sess, &ut_params->cipher_xform,
1701                         ts_params->session_priv_mpool);
1702         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1703
1704         /* Generate crypto op data structure */
1705         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1706                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1707         TEST_ASSERT_NOT_NULL(ut_params->op,
1708                         "Failed to allocate symmetric crypto operation struct");
1709
1710         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1711
1712         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1713
1714         /* set crypto operation source mbuf */
1715         sym_op->m_src = ut_params->ibuf;
1716
1717         /* Set crypto operation authentication parameters */
1718         sym_op->auth.digest.data = ut_params->digest;
1719         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1720                         ut_params->ibuf, QUOTE_512_BYTES);
1721
1722         sym_op->auth.data.offset = 0;
1723         sym_op->auth.data.length = QUOTE_512_BYTES;
1724
1725         /* Copy IV at the end of the crypto operation */
1726         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1727                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1728
1729         /* Set crypto operation cipher parameters */
1730         sym_op->cipher.data.offset = 0;
1731         sym_op->cipher.data.length = QUOTE_512_BYTES;
1732
1733         /* Process crypto operation */
1734         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1735                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1736                         ut_params->op);
1737         else
1738                 TEST_ASSERT_NOT_NULL(
1739                         process_crypto_request(ts_params->valid_devs[0],
1740                                 ut_params->op),
1741                                 "failed to process sym crypto op");
1742
1743         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1744                         "crypto op processing failed");
1745
1746         /* Validate obuf */
1747         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1748                         uint8_t *);
1749
1750         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1751                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1752                         QUOTE_512_BYTES,
1753                         "ciphertext data not as expected");
1754
1755         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1756
1757         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1758                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1759                         gbl_driver_id == rte_cryptodev_driver_id_get(
1760                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1761                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1762                                         DIGEST_BYTE_LENGTH_SHA1,
1763                         "Generated digest data not as expected");
1764
1765         return TEST_SUCCESS;
1766 }
1767
1768 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1769
1770 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1771
1772 static uint8_t hmac_sha512_key[] = {
1773         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1774         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1775         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1776         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1777         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1778         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1779         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1780         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1781
1782 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1783         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1784         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1785         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1786         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1787         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1788         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1789         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1790         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1791
1792
1793
1794 static int
1795 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1796                 struct crypto_unittest_params *ut_params,
1797                 uint8_t *cipher_key,
1798                 uint8_t *hmac_key);
1799
1800 static int
1801 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1802                 struct crypto_unittest_params *ut_params,
1803                 struct crypto_testsuite_params *ts_params,
1804                 const uint8_t *cipher,
1805                 const uint8_t *digest,
1806                 const uint8_t *iv);
1807
1808
1809 static int
1810 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1811                 struct crypto_unittest_params *ut_params,
1812                 uint8_t *cipher_key,
1813                 uint8_t *hmac_key)
1814 {
1815
1816         /* Setup Cipher Parameters */
1817         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1818         ut_params->cipher_xform.next = NULL;
1819
1820         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1821         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1822         ut_params->cipher_xform.cipher.key.data = cipher_key;
1823         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1824         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1825         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1826
1827         /* Setup HMAC Parameters */
1828         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1829         ut_params->auth_xform.next = &ut_params->cipher_xform;
1830
1831         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1832         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1833         ut_params->auth_xform.auth.key.data = hmac_key;
1834         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1835         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1836
1837         return TEST_SUCCESS;
1838 }
1839
1840
1841 static int
1842 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1843                 struct crypto_unittest_params *ut_params,
1844                 struct crypto_testsuite_params *ts_params,
1845                 const uint8_t *cipher,
1846                 const uint8_t *digest,
1847                 const uint8_t *iv)
1848 {
1849         /* Generate test mbuf data and digest */
1850         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1851                         (const char *)
1852                         cipher,
1853                         QUOTE_512_BYTES, 0);
1854
1855         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1856                         DIGEST_BYTE_LENGTH_SHA512);
1857         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1858
1859         rte_memcpy(ut_params->digest,
1860                         digest,
1861                         DIGEST_BYTE_LENGTH_SHA512);
1862
1863         /* Generate Crypto op data structure */
1864         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1865                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1866         TEST_ASSERT_NOT_NULL(ut_params->op,
1867                         "Failed to allocate symmetric crypto operation struct");
1868
1869         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1870
1871         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1872
1873         /* set crypto operation source mbuf */
1874         sym_op->m_src = ut_params->ibuf;
1875
1876         sym_op->auth.digest.data = ut_params->digest;
1877         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1878                         ut_params->ibuf, QUOTE_512_BYTES);
1879
1880         sym_op->auth.data.offset = 0;
1881         sym_op->auth.data.length = QUOTE_512_BYTES;
1882
1883         /* Copy IV at the end of the crypto operation */
1884         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1885                         iv, CIPHER_IV_LENGTH_AES_CBC);
1886
1887         sym_op->cipher.data.offset = 0;
1888         sym_op->cipher.data.length = QUOTE_512_BYTES;
1889
1890         /* Process crypto operation */
1891         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1892                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1893                         ut_params->op);
1894         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1895                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
1896                                 ut_params->op, 1, 1, 0, 0);
1897         else
1898                 TEST_ASSERT_NOT_NULL(
1899                                 process_crypto_request(ts_params->valid_devs[0],
1900                                         ut_params->op),
1901                                         "failed to process sym crypto op");
1902
1903         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1904                         "crypto op processing failed");
1905
1906         ut_params->obuf = ut_params->op->sym->m_src;
1907
1908         /* Validate obuf */
1909         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1910                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1911                         catch_22_quote,
1912                         QUOTE_512_BYTES,
1913                         "Plaintext data not as expected");
1914
1915         /* Validate obuf */
1916         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1917                         "Digest verification failed");
1918
1919         return TEST_SUCCESS;
1920 }
1921
1922 static int
1923 test_blockcipher(enum blockcipher_test_type test_type)
1924 {
1925         struct crypto_testsuite_params *ts_params = &testsuite_params;
1926         int status;
1927
1928         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1929                 ts_params->op_mpool,
1930                 ts_params->session_mpool, ts_params->session_priv_mpool,
1931                 ts_params->valid_devs[0],
1932                 test_type);
1933
1934         if (status == -ENOTSUP)
1935                 return status;
1936
1937         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1938
1939         return TEST_SUCCESS;
1940 }
1941
1942 static int
1943 test_AES_cipheronly_all(void)
1944 {
1945         return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
1946 }
1947
1948 static int
1949 test_AES_docsis_all(void)
1950 {
1951         /* Data-path service does not support DOCSIS yet */
1952         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1953                 return -ENOTSUP;
1954         return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
1955 }
1956
1957 static int
1958 test_DES_docsis_all(void)
1959 {
1960         /* Data-path service does not support DOCSIS yet */
1961         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1962                 return -ENOTSUP;
1963         return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
1964 }
1965
1966 static int
1967 test_DES_cipheronly_all(void)
1968 {
1969         return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
1970 }
1971
1972 static int
1973 test_authonly_all(void)
1974 {
1975         return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
1976 }
1977
1978 static int
1979 test_AES_chain_all(void)
1980 {
1981         return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
1982 }
1983
1984 static int
1985 test_3DES_chain_all(void)
1986 {
1987         return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
1988 }
1989
1990 static int
1991 test_3DES_cipheronly_all(void)
1992 {
1993         return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
1994 }
1995
1996 /* ***** SNOW 3G Tests ***** */
1997 static int
1998 create_wireless_algo_hash_session(uint8_t dev_id,
1999         const uint8_t *key, const uint8_t key_len,
2000         const uint8_t iv_len, const uint8_t auth_len,
2001         enum rte_crypto_auth_operation op,
2002         enum rte_crypto_auth_algorithm algo)
2003 {
2004         uint8_t hash_key[key_len];
2005         int status;
2006
2007         struct crypto_testsuite_params *ts_params = &testsuite_params;
2008         struct crypto_unittest_params *ut_params = &unittest_params;
2009
2010         memcpy(hash_key, key, key_len);
2011
2012         debug_hexdump(stdout, "key:", key, key_len);
2013
2014         /* Setup Authentication Parameters */
2015         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2016         ut_params->auth_xform.next = NULL;
2017
2018         ut_params->auth_xform.auth.op = op;
2019         ut_params->auth_xform.auth.algo = algo;
2020         ut_params->auth_xform.auth.key.length = key_len;
2021         ut_params->auth_xform.auth.key.data = hash_key;
2022         ut_params->auth_xform.auth.digest_length = auth_len;
2023         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2024         ut_params->auth_xform.auth.iv.length = iv_len;
2025         ut_params->sess = rte_cryptodev_sym_session_create(
2026                         ts_params->session_mpool);
2027
2028         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2029                         &ut_params->auth_xform,
2030                         ts_params->session_priv_mpool);
2031         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2032         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2033         return 0;
2034 }
2035
2036 static int
2037 create_wireless_algo_cipher_session(uint8_t dev_id,
2038                         enum rte_crypto_cipher_operation op,
2039                         enum rte_crypto_cipher_algorithm algo,
2040                         const uint8_t *key, const uint8_t key_len,
2041                         uint8_t iv_len)
2042 {
2043         uint8_t cipher_key[key_len];
2044         int status;
2045         struct crypto_testsuite_params *ts_params = &testsuite_params;
2046         struct crypto_unittest_params *ut_params = &unittest_params;
2047
2048         memcpy(cipher_key, key, key_len);
2049
2050         /* Setup Cipher Parameters */
2051         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2052         ut_params->cipher_xform.next = NULL;
2053
2054         ut_params->cipher_xform.cipher.algo = algo;
2055         ut_params->cipher_xform.cipher.op = op;
2056         ut_params->cipher_xform.cipher.key.data = cipher_key;
2057         ut_params->cipher_xform.cipher.key.length = key_len;
2058         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2059         ut_params->cipher_xform.cipher.iv.length = iv_len;
2060
2061         debug_hexdump(stdout, "key:", key, key_len);
2062
2063         /* Create Crypto session */
2064         ut_params->sess = rte_cryptodev_sym_session_create(
2065                         ts_params->session_mpool);
2066
2067         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2068                         &ut_params->cipher_xform,
2069                         ts_params->session_priv_mpool);
2070         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2071         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2072         return 0;
2073 }
2074
2075 static int
2076 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2077                         unsigned int cipher_len,
2078                         unsigned int cipher_offset)
2079 {
2080         struct crypto_testsuite_params *ts_params = &testsuite_params;
2081         struct crypto_unittest_params *ut_params = &unittest_params;
2082
2083         /* Generate Crypto op data structure */
2084         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2085                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2086         TEST_ASSERT_NOT_NULL(ut_params->op,
2087                                 "Failed to allocate pktmbuf offload");
2088
2089         /* Set crypto operation data parameters */
2090         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2091
2092         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2093
2094         /* set crypto operation source mbuf */
2095         sym_op->m_src = ut_params->ibuf;
2096
2097         /* iv */
2098         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2099                         iv, iv_len);
2100         sym_op->cipher.data.length = cipher_len;
2101         sym_op->cipher.data.offset = cipher_offset;
2102         return 0;
2103 }
2104
2105 static int
2106 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2107                         unsigned int cipher_len,
2108                         unsigned int cipher_offset)
2109 {
2110         struct crypto_testsuite_params *ts_params = &testsuite_params;
2111         struct crypto_unittest_params *ut_params = &unittest_params;
2112
2113         /* Generate Crypto op data structure */
2114         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2115                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2116         TEST_ASSERT_NOT_NULL(ut_params->op,
2117                                 "Failed to allocate pktmbuf offload");
2118
2119         /* Set crypto operation data parameters */
2120         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2121
2122         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2123
2124         /* set crypto operation source mbuf */
2125         sym_op->m_src = ut_params->ibuf;
2126         sym_op->m_dst = ut_params->obuf;
2127
2128         /* iv */
2129         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2130                         iv, iv_len);
2131         sym_op->cipher.data.length = cipher_len;
2132         sym_op->cipher.data.offset = cipher_offset;
2133         return 0;
2134 }
2135
2136 static int
2137 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2138                 enum rte_crypto_cipher_operation cipher_op,
2139                 enum rte_crypto_auth_operation auth_op,
2140                 enum rte_crypto_auth_algorithm auth_algo,
2141                 enum rte_crypto_cipher_algorithm cipher_algo,
2142                 const uint8_t *key, uint8_t key_len,
2143                 uint8_t auth_iv_len, uint8_t auth_len,
2144                 uint8_t cipher_iv_len)
2145
2146 {
2147         uint8_t cipher_auth_key[key_len];
2148         int status;
2149
2150         struct crypto_testsuite_params *ts_params = &testsuite_params;
2151         struct crypto_unittest_params *ut_params = &unittest_params;
2152
2153         memcpy(cipher_auth_key, key, key_len);
2154
2155         /* Setup Authentication Parameters */
2156         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2157         ut_params->auth_xform.next = NULL;
2158
2159         ut_params->auth_xform.auth.op = auth_op;
2160         ut_params->auth_xform.auth.algo = auth_algo;
2161         ut_params->auth_xform.auth.key.length = key_len;
2162         /* Hash key = cipher key */
2163         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2164         ut_params->auth_xform.auth.digest_length = auth_len;
2165         /* Auth IV will be after cipher IV */
2166         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2167         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2168
2169         /* Setup Cipher Parameters */
2170         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2171         ut_params->cipher_xform.next = &ut_params->auth_xform;
2172
2173         ut_params->cipher_xform.cipher.algo = cipher_algo;
2174         ut_params->cipher_xform.cipher.op = cipher_op;
2175         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2176         ut_params->cipher_xform.cipher.key.length = key_len;
2177         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2178         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2179
2180         debug_hexdump(stdout, "key:", key, key_len);
2181
2182         /* Create Crypto session*/
2183         ut_params->sess = rte_cryptodev_sym_session_create(
2184                         ts_params->session_mpool);
2185         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2186
2187         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2188                         &ut_params->cipher_xform,
2189                         ts_params->session_priv_mpool);
2190         if (status == -ENOTSUP)
2191                 return status;
2192
2193         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2194         return 0;
2195 }
2196
2197 static int
2198 create_wireless_cipher_auth_session(uint8_t dev_id,
2199                 enum rte_crypto_cipher_operation cipher_op,
2200                 enum rte_crypto_auth_operation auth_op,
2201                 enum rte_crypto_auth_algorithm auth_algo,
2202                 enum rte_crypto_cipher_algorithm cipher_algo,
2203                 const struct wireless_test_data *tdata)
2204 {
2205         const uint8_t key_len = tdata->key.len;
2206         uint8_t cipher_auth_key[key_len];
2207         int status;
2208
2209         struct crypto_testsuite_params *ts_params = &testsuite_params;
2210         struct crypto_unittest_params *ut_params = &unittest_params;
2211         const uint8_t *key = tdata->key.data;
2212         const uint8_t auth_len = tdata->digest.len;
2213         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2214         uint8_t auth_iv_len = tdata->auth_iv.len;
2215
2216         memcpy(cipher_auth_key, key, key_len);
2217
2218         /* Setup Authentication Parameters */
2219         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2220         ut_params->auth_xform.next = NULL;
2221
2222         ut_params->auth_xform.auth.op = auth_op;
2223         ut_params->auth_xform.auth.algo = auth_algo;
2224         ut_params->auth_xform.auth.key.length = key_len;
2225         /* Hash key = cipher key */
2226         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2227         ut_params->auth_xform.auth.digest_length = auth_len;
2228         /* Auth IV will be after cipher IV */
2229         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2230         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2231
2232         /* Setup Cipher Parameters */
2233         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2234         ut_params->cipher_xform.next = &ut_params->auth_xform;
2235
2236         ut_params->cipher_xform.cipher.algo = cipher_algo;
2237         ut_params->cipher_xform.cipher.op = cipher_op;
2238         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2239         ut_params->cipher_xform.cipher.key.length = key_len;
2240         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2241         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2242
2243
2244         debug_hexdump(stdout, "key:", key, key_len);
2245
2246         /* Create Crypto session*/
2247         ut_params->sess = rte_cryptodev_sym_session_create(
2248                         ts_params->session_mpool);
2249
2250         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2251                         &ut_params->cipher_xform,
2252                         ts_params->session_priv_mpool);
2253         if (status == -ENOTSUP)
2254                 return status;
2255
2256         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2257         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2258         return 0;
2259 }
2260
2261 static int
2262 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2263                 const struct wireless_test_data *tdata)
2264 {
2265         return create_wireless_cipher_auth_session(dev_id,
2266                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2267                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2268                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2269 }
2270
2271 static int
2272 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2273                 enum rte_crypto_cipher_operation cipher_op,
2274                 enum rte_crypto_auth_operation auth_op,
2275                 enum rte_crypto_auth_algorithm auth_algo,
2276                 enum rte_crypto_cipher_algorithm cipher_algo,
2277                 const uint8_t *key, const uint8_t key_len,
2278                 uint8_t auth_iv_len, uint8_t auth_len,
2279                 uint8_t cipher_iv_len)
2280 {
2281         uint8_t auth_cipher_key[key_len];
2282         int status;
2283         struct crypto_testsuite_params *ts_params = &testsuite_params;
2284         struct crypto_unittest_params *ut_params = &unittest_params;
2285
2286         memcpy(auth_cipher_key, key, key_len);
2287
2288         /* Setup Authentication Parameters */
2289         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2290         ut_params->auth_xform.auth.op = auth_op;
2291         ut_params->auth_xform.next = &ut_params->cipher_xform;
2292         ut_params->auth_xform.auth.algo = auth_algo;
2293         ut_params->auth_xform.auth.key.length = key_len;
2294         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2295         ut_params->auth_xform.auth.digest_length = auth_len;
2296         /* Auth IV will be after cipher IV */
2297         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2298         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2299
2300         /* Setup Cipher Parameters */
2301         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2302         ut_params->cipher_xform.next = NULL;
2303         ut_params->cipher_xform.cipher.algo = cipher_algo;
2304         ut_params->cipher_xform.cipher.op = cipher_op;
2305         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2306         ut_params->cipher_xform.cipher.key.length = key_len;
2307         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2308         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2309
2310         debug_hexdump(stdout, "key:", key, key_len);
2311
2312         /* Create Crypto session*/
2313         ut_params->sess = rte_cryptodev_sym_session_create(
2314                         ts_params->session_mpool);
2315         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2316
2317         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2318                 ut_params->auth_xform.next = NULL;
2319                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2320                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2321                                 &ut_params->cipher_xform,
2322                                 ts_params->session_priv_mpool);
2323
2324         } else
2325                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2326                                 &ut_params->auth_xform,
2327                                 ts_params->session_priv_mpool);
2328
2329         if (status == -ENOTSUP)
2330                 return status;
2331
2332         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2333
2334         return 0;
2335 }
2336
2337 static int
2338 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2339                 unsigned int auth_tag_len,
2340                 const uint8_t *iv, unsigned int iv_len,
2341                 unsigned int data_pad_len,
2342                 enum rte_crypto_auth_operation op,
2343                 unsigned int auth_len, unsigned int auth_offset)
2344 {
2345         struct crypto_testsuite_params *ts_params = &testsuite_params;
2346
2347         struct crypto_unittest_params *ut_params = &unittest_params;
2348
2349         /* Generate Crypto op data structure */
2350         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2351                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2352         TEST_ASSERT_NOT_NULL(ut_params->op,
2353                 "Failed to allocate pktmbuf offload");
2354
2355         /* Set crypto operation data parameters */
2356         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2357
2358         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2359
2360         /* set crypto operation source mbuf */
2361         sym_op->m_src = ut_params->ibuf;
2362
2363         /* iv */
2364         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2365                         iv, iv_len);
2366         /* digest */
2367         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2368                                         ut_params->ibuf, auth_tag_len);
2369
2370         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2371                                 "no room to append auth tag");
2372         ut_params->digest = sym_op->auth.digest.data;
2373         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2374                         ut_params->ibuf, data_pad_len);
2375         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2376                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2377         else
2378                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2379
2380         debug_hexdump(stdout, "digest:",
2381                 sym_op->auth.digest.data,
2382                 auth_tag_len);
2383
2384         sym_op->auth.data.length = auth_len;
2385         sym_op->auth.data.offset = auth_offset;
2386
2387         return 0;
2388 }
2389
2390 static int
2391 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2392         enum rte_crypto_auth_operation op)
2393 {
2394         struct crypto_testsuite_params *ts_params = &testsuite_params;
2395         struct crypto_unittest_params *ut_params = &unittest_params;
2396
2397         const uint8_t *auth_tag = tdata->digest.data;
2398         const unsigned int auth_tag_len = tdata->digest.len;
2399         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2400         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2401
2402         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2403         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2404         const uint8_t *auth_iv = tdata->auth_iv.data;
2405         const uint8_t auth_iv_len = tdata->auth_iv.len;
2406         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2407         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2408
2409         /* Generate Crypto op data structure */
2410         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2411                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2412         TEST_ASSERT_NOT_NULL(ut_params->op,
2413                         "Failed to allocate pktmbuf offload");
2414         /* Set crypto operation data parameters */
2415         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2416
2417         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2418
2419         /* set crypto operation source mbuf */
2420         sym_op->m_src = ut_params->ibuf;
2421
2422         /* digest */
2423         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2424                         ut_params->ibuf, auth_tag_len);
2425
2426         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2427                         "no room to append auth tag");
2428         ut_params->digest = sym_op->auth.digest.data;
2429         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2430                         ut_params->ibuf, data_pad_len);
2431         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2432                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2433         else
2434                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2435
2436         debug_hexdump(stdout, "digest:",
2437                 sym_op->auth.digest.data,
2438                 auth_tag_len);
2439
2440         /* Copy cipher and auth IVs at the end of the crypto operation */
2441         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2442                                                 IV_OFFSET);
2443         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2444         iv_ptr += cipher_iv_len;
2445         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2446
2447         sym_op->cipher.data.length = cipher_len;
2448         sym_op->cipher.data.offset = 0;
2449         sym_op->auth.data.length = auth_len;
2450         sym_op->auth.data.offset = 0;
2451
2452         return 0;
2453 }
2454
2455 static int
2456 create_zuc_cipher_hash_generate_operation(
2457                 const struct wireless_test_data *tdata)
2458 {
2459         return create_wireless_cipher_hash_operation(tdata,
2460                 RTE_CRYPTO_AUTH_OP_GENERATE);
2461 }
2462
2463 static int
2464 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2465                 const unsigned auth_tag_len,
2466                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2467                 unsigned data_pad_len,
2468                 enum rte_crypto_auth_operation op,
2469                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2470                 const unsigned cipher_len, const unsigned cipher_offset,
2471                 const unsigned auth_len, const unsigned auth_offset)
2472 {
2473         struct crypto_testsuite_params *ts_params = &testsuite_params;
2474         struct crypto_unittest_params *ut_params = &unittest_params;
2475
2476         enum rte_crypto_cipher_algorithm cipher_algo =
2477                         ut_params->cipher_xform.cipher.algo;
2478         enum rte_crypto_auth_algorithm auth_algo =
2479                         ut_params->auth_xform.auth.algo;
2480
2481         /* Generate Crypto op data structure */
2482         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2483                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2484         TEST_ASSERT_NOT_NULL(ut_params->op,
2485                         "Failed to allocate pktmbuf offload");
2486         /* Set crypto operation data parameters */
2487         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2488
2489         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2490
2491         /* set crypto operation source mbuf */
2492         sym_op->m_src = ut_params->ibuf;
2493
2494         /* digest */
2495         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2496                         ut_params->ibuf, auth_tag_len);
2497
2498         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2499                         "no room to append auth tag");
2500         ut_params->digest = sym_op->auth.digest.data;
2501
2502         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2503                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2504                                 ut_params->ibuf, data_pad_len);
2505         } else {
2506                 struct rte_mbuf *m = ut_params->ibuf;
2507                 unsigned int offset = data_pad_len;
2508
2509                 while (offset > m->data_len && m->next != NULL) {
2510                         offset -= m->data_len;
2511                         m = m->next;
2512                 }
2513                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2514                         m, offset);
2515         }
2516
2517         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2518                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2519         else
2520                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2521
2522         debug_hexdump(stdout, "digest:",
2523                 sym_op->auth.digest.data,
2524                 auth_tag_len);
2525
2526         /* Copy cipher and auth IVs at the end of the crypto operation */
2527         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2528                                                 IV_OFFSET);
2529         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2530         iv_ptr += cipher_iv_len;
2531         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2532
2533         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2534                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2535                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2536                 sym_op->cipher.data.length = cipher_len;
2537                 sym_op->cipher.data.offset = cipher_offset;
2538         } else {
2539                 sym_op->cipher.data.length = cipher_len >> 3;
2540                 sym_op->cipher.data.offset = cipher_offset >> 3;
2541         }
2542
2543         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2544                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2545                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2546                 sym_op->auth.data.length = auth_len;
2547                 sym_op->auth.data.offset = auth_offset;
2548         } else {
2549                 sym_op->auth.data.length = auth_len >> 3;
2550                 sym_op->auth.data.offset = auth_offset >> 3;
2551         }
2552
2553         return 0;
2554 }
2555
2556 static int
2557 create_wireless_algo_auth_cipher_operation(
2558                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2559                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2560                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2561                 unsigned int data_pad_len,
2562                 unsigned int cipher_len, unsigned int cipher_offset,
2563                 unsigned int auth_len, unsigned int auth_offset,
2564                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2565 {
2566         struct crypto_testsuite_params *ts_params = &testsuite_params;
2567         struct crypto_unittest_params *ut_params = &unittest_params;
2568
2569         enum rte_crypto_cipher_algorithm cipher_algo =
2570                         ut_params->cipher_xform.cipher.algo;
2571         enum rte_crypto_auth_algorithm auth_algo =
2572                         ut_params->auth_xform.auth.algo;
2573
2574         /* Generate Crypto op data structure */
2575         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2576                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2577         TEST_ASSERT_NOT_NULL(ut_params->op,
2578                         "Failed to allocate pktmbuf offload");
2579
2580         /* Set crypto operation data parameters */
2581         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2582
2583         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2584
2585         /* set crypto operation mbufs */
2586         sym_op->m_src = ut_params->ibuf;
2587         if (op_mode == OUT_OF_PLACE)
2588                 sym_op->m_dst = ut_params->obuf;
2589
2590         /* digest */
2591         if (!do_sgl) {
2592                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2593                         (op_mode == IN_PLACE ?
2594                                 ut_params->ibuf : ut_params->obuf),
2595                         uint8_t *, data_pad_len);
2596                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2597                         (op_mode == IN_PLACE ?
2598                                 ut_params->ibuf : ut_params->obuf),
2599                         data_pad_len);
2600                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2601         } else {
2602                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2603                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2604                                 sym_op->m_src : sym_op->m_dst);
2605                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2606                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2607                         sgl_buf = sgl_buf->next;
2608                 }
2609                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2610                                 uint8_t *, remaining_off);
2611                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2612                                 remaining_off);
2613                 memset(sym_op->auth.digest.data, 0, remaining_off);
2614                 while (sgl_buf->next != NULL) {
2615                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2616                                 0, rte_pktmbuf_data_len(sgl_buf));
2617                         sgl_buf = sgl_buf->next;
2618                 }
2619         }
2620
2621         /* Copy digest for the verification */
2622         if (verify)
2623                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2624
2625         /* Copy cipher and auth IVs at the end of the crypto operation */
2626         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2627                         ut_params->op, uint8_t *, IV_OFFSET);
2628
2629         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2630         iv_ptr += cipher_iv_len;
2631         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2632
2633         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2634                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2635                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2636                 sym_op->cipher.data.length = cipher_len;
2637                 sym_op->cipher.data.offset = cipher_offset;
2638         } else {
2639                 sym_op->cipher.data.length = cipher_len >> 3;
2640                 sym_op->cipher.data.offset = cipher_offset >> 3;
2641         }
2642
2643         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2644                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2645                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2646                 sym_op->auth.data.length = auth_len;
2647                 sym_op->auth.data.offset = auth_offset;
2648         } else {
2649                 sym_op->auth.data.length = auth_len >> 3;
2650                 sym_op->auth.data.offset = auth_offset >> 3;
2651         }
2652
2653         return 0;
2654 }
2655
2656 static int
2657 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2658 {
2659         struct crypto_testsuite_params *ts_params = &testsuite_params;
2660         struct crypto_unittest_params *ut_params = &unittest_params;
2661
2662         int retval;
2663         unsigned plaintext_pad_len;
2664         unsigned plaintext_len;
2665         uint8_t *plaintext;
2666         struct rte_cryptodev_info dev_info;
2667
2668         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2669         uint64_t feat_flags = dev_info.feature_flags;
2670
2671         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2672                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2673                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2674                 return -ENOTSUP;
2675         }
2676
2677         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2678                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2679                 printf("Device doesn't support RAW data-path APIs.\n");
2680                 return -ENOTSUP;
2681         }
2682
2683         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2684                 return -ENOTSUP;
2685
2686         /* Verify the capabilities */
2687         struct rte_cryptodev_sym_capability_idx cap_idx;
2688         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2689         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2690         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2691                         &cap_idx) == NULL)
2692                 return -ENOTSUP;
2693
2694         /* Create SNOW 3G session */
2695         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2696                         tdata->key.data, tdata->key.len,
2697                         tdata->auth_iv.len, tdata->digest.len,
2698                         RTE_CRYPTO_AUTH_OP_GENERATE,
2699                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2700         if (retval < 0)
2701                 return retval;
2702
2703         /* alloc mbuf and set payload */
2704         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2705
2706         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2707         rte_pktmbuf_tailroom(ut_params->ibuf));
2708
2709         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2710         /* Append data which is padded to a multiple of */
2711         /* the algorithms block size */
2712         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2713         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2714                                 plaintext_pad_len);
2715         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2716
2717         /* Create SNOW 3G operation */
2718         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2719                         tdata->auth_iv.data, tdata->auth_iv.len,
2720                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2721                         tdata->validAuthLenInBits.len,
2722                         0);
2723         if (retval < 0)
2724                 return retval;
2725
2726         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2727                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2728                                 ut_params->op, 0, 1, 1, 0);
2729         else
2730                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2731                                 ut_params->op);
2732         ut_params->obuf = ut_params->op->sym->m_src;
2733         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2734         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2735                         + plaintext_pad_len;
2736
2737         /* Validate obuf */
2738         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2739         ut_params->digest,
2740         tdata->digest.data,
2741         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2742         "SNOW 3G Generated auth tag not as expected");
2743
2744         return 0;
2745 }
2746
2747 static int
2748 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2749 {
2750         struct crypto_testsuite_params *ts_params = &testsuite_params;
2751         struct crypto_unittest_params *ut_params = &unittest_params;
2752
2753         int retval;
2754         unsigned plaintext_pad_len;
2755         unsigned plaintext_len;
2756         uint8_t *plaintext;
2757         struct rte_cryptodev_info dev_info;
2758
2759         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2760         uint64_t feat_flags = dev_info.feature_flags;
2761
2762         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2763                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2764                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2765                 return -ENOTSUP;
2766         }
2767
2768         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2769                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2770                 printf("Device doesn't support RAW data-path APIs.\n");
2771                 return -ENOTSUP;
2772         }
2773
2774         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2775                 return -ENOTSUP;
2776
2777         /* Verify the capabilities */
2778         struct rte_cryptodev_sym_capability_idx cap_idx;
2779         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2780         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2781         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2782                         &cap_idx) == NULL)
2783                 return -ENOTSUP;
2784
2785         /* Create SNOW 3G session */
2786         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2787                                 tdata->key.data, tdata->key.len,
2788                                 tdata->auth_iv.len, tdata->digest.len,
2789                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2790                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2791         if (retval < 0)
2792                 return retval;
2793         /* alloc mbuf and set payload */
2794         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2795
2796         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2797         rte_pktmbuf_tailroom(ut_params->ibuf));
2798
2799         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2800         /* Append data which is padded to a multiple of */
2801         /* the algorithms block size */
2802         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2803         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2804                                 plaintext_pad_len);
2805         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2806
2807         /* Create SNOW 3G operation */
2808         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2809                         tdata->digest.len,
2810                         tdata->auth_iv.data, tdata->auth_iv.len,
2811                         plaintext_pad_len,
2812                         RTE_CRYPTO_AUTH_OP_VERIFY,
2813                         tdata->validAuthLenInBits.len,
2814                         0);
2815         if (retval < 0)
2816                 return retval;
2817
2818         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2819                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2820                                 ut_params->op, 0, 1, 1, 0);
2821         else
2822                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2823                                 ut_params->op);
2824         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2825         ut_params->obuf = ut_params->op->sym->m_src;
2826         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2827                                 + plaintext_pad_len;
2828
2829         /* Validate obuf */
2830         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2831                 return 0;
2832         else
2833                 return -1;
2834
2835         return 0;
2836 }
2837
2838 static int
2839 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2840 {
2841         struct crypto_testsuite_params *ts_params = &testsuite_params;
2842         struct crypto_unittest_params *ut_params = &unittest_params;
2843
2844         int retval;
2845         unsigned plaintext_pad_len;
2846         unsigned plaintext_len;
2847         uint8_t *plaintext;
2848         struct rte_cryptodev_info dev_info;
2849
2850         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2851         uint64_t feat_flags = dev_info.feature_flags;
2852
2853         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2854                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2855                 printf("Device doesn't support RAW data-path APIs.\n");
2856                 return -ENOTSUP;
2857         }
2858
2859         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2860                 return -ENOTSUP;
2861
2862         /* Verify the capabilities */
2863         struct rte_cryptodev_sym_capability_idx cap_idx;
2864         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2865         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2866         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2867                         &cap_idx) == NULL)
2868                 return -ENOTSUP;
2869
2870         /* Create KASUMI session */
2871         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2872                         tdata->key.data, tdata->key.len,
2873                         0, tdata->digest.len,
2874                         RTE_CRYPTO_AUTH_OP_GENERATE,
2875                         RTE_CRYPTO_AUTH_KASUMI_F9);
2876         if (retval < 0)
2877                 return retval;
2878
2879         /* alloc mbuf and set payload */
2880         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2881
2882         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2883         rte_pktmbuf_tailroom(ut_params->ibuf));
2884
2885         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2886         /* Append data which is padded to a multiple of */
2887         /* the algorithms block size */
2888         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2889         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2890                                 plaintext_pad_len);
2891         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2892
2893         /* Create KASUMI operation */
2894         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2895                         NULL, 0,
2896                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2897                         tdata->plaintext.len,
2898                         0);
2899         if (retval < 0)
2900                 return retval;
2901
2902         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2903                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2904                         ut_params->op);
2905         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2906                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2907                                 ut_params->op, 0, 1, 1, 0);
2908         else
2909                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2910                         ut_params->op);
2911
2912         ut_params->obuf = ut_params->op->sym->m_src;
2913         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2914         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2915                         + plaintext_pad_len;
2916
2917         /* Validate obuf */
2918         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2919         ut_params->digest,
2920         tdata->digest.data,
2921         DIGEST_BYTE_LENGTH_KASUMI_F9,
2922         "KASUMI Generated auth tag not as expected");
2923
2924         return 0;
2925 }
2926
2927 static int
2928 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2929 {
2930         struct crypto_testsuite_params *ts_params = &testsuite_params;
2931         struct crypto_unittest_params *ut_params = &unittest_params;
2932
2933         int retval;
2934         unsigned plaintext_pad_len;
2935         unsigned plaintext_len;
2936         uint8_t *plaintext;
2937         struct rte_cryptodev_info dev_info;
2938
2939         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2940         uint64_t feat_flags = dev_info.feature_flags;
2941
2942         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2943                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2944                 printf("Device doesn't support RAW data-path APIs.\n");
2945                 return -ENOTSUP;
2946         }
2947
2948         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2949                 return -ENOTSUP;
2950
2951         /* Verify the capabilities */
2952         struct rte_cryptodev_sym_capability_idx cap_idx;
2953         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2954         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2955         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2956                         &cap_idx) == NULL)
2957                 return -ENOTSUP;
2958
2959         /* Create KASUMI session */
2960         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2961                                 tdata->key.data, tdata->key.len,
2962                                 0, tdata->digest.len,
2963                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2964                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2965         if (retval < 0)
2966                 return retval;
2967         /* alloc mbuf and set payload */
2968         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2969
2970         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2971         rte_pktmbuf_tailroom(ut_params->ibuf));
2972
2973         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2974         /* Append data which is padded to a multiple */
2975         /* of the algorithms block size */
2976         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2977         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2978                                 plaintext_pad_len);
2979         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2980
2981         /* Create KASUMI operation */
2982         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2983                         tdata->digest.len,
2984                         NULL, 0,
2985                         plaintext_pad_len,
2986                         RTE_CRYPTO_AUTH_OP_VERIFY,
2987                         tdata->plaintext.len,
2988                         0);
2989         if (retval < 0)
2990                 return retval;
2991
2992         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2993                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2994                                 ut_params->op, 0, 1, 1, 0);
2995         else
2996                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2997                                 ut_params->op);
2998         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2999         ut_params->obuf = ut_params->op->sym->m_src;
3000         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3001                                 + plaintext_pad_len;
3002
3003         /* Validate obuf */
3004         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3005                 return 0;
3006         else
3007                 return -1;
3008
3009         return 0;
3010 }
3011
3012 static int
3013 test_snow3g_hash_generate_test_case_1(void)
3014 {
3015         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3016 }
3017
3018 static int
3019 test_snow3g_hash_generate_test_case_2(void)
3020 {
3021         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3022 }
3023
3024 static int
3025 test_snow3g_hash_generate_test_case_3(void)
3026 {
3027         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3028 }
3029
3030 static int
3031 test_snow3g_hash_generate_test_case_4(void)
3032 {
3033         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3034 }
3035
3036 static int
3037 test_snow3g_hash_generate_test_case_5(void)
3038 {
3039         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3040 }
3041
3042 static int
3043 test_snow3g_hash_generate_test_case_6(void)
3044 {
3045         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3046 }
3047
3048 static int
3049 test_snow3g_hash_verify_test_case_1(void)
3050 {
3051         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3052
3053 }
3054
3055 static int
3056 test_snow3g_hash_verify_test_case_2(void)
3057 {
3058         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3059 }
3060
3061 static int
3062 test_snow3g_hash_verify_test_case_3(void)
3063 {
3064         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3065 }
3066
3067 static int
3068 test_snow3g_hash_verify_test_case_4(void)
3069 {
3070         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3071 }
3072
3073 static int
3074 test_snow3g_hash_verify_test_case_5(void)
3075 {
3076         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3077 }
3078
3079 static int
3080 test_snow3g_hash_verify_test_case_6(void)
3081 {
3082         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3083 }
3084
3085 static int
3086 test_kasumi_hash_generate_test_case_1(void)
3087 {
3088         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3089 }
3090
3091 static int
3092 test_kasumi_hash_generate_test_case_2(void)
3093 {
3094         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3095 }
3096
3097 static int
3098 test_kasumi_hash_generate_test_case_3(void)
3099 {
3100         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3101 }
3102
3103 static int
3104 test_kasumi_hash_generate_test_case_4(void)
3105 {
3106         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3107 }
3108
3109 static int
3110 test_kasumi_hash_generate_test_case_5(void)
3111 {
3112         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3113 }
3114
3115 static int
3116 test_kasumi_hash_generate_test_case_6(void)
3117 {
3118         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3119 }
3120
3121 static int
3122 test_kasumi_hash_verify_test_case_1(void)
3123 {
3124         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3125 }
3126
3127 static int
3128 test_kasumi_hash_verify_test_case_2(void)
3129 {
3130         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3131 }
3132
3133 static int
3134 test_kasumi_hash_verify_test_case_3(void)
3135 {
3136         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3137 }
3138
3139 static int
3140 test_kasumi_hash_verify_test_case_4(void)
3141 {
3142         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3143 }
3144
3145 static int
3146 test_kasumi_hash_verify_test_case_5(void)
3147 {
3148         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3149 }
3150
3151 static int
3152 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3153 {
3154         struct crypto_testsuite_params *ts_params = &testsuite_params;
3155         struct crypto_unittest_params *ut_params = &unittest_params;
3156
3157         int retval;
3158         uint8_t *plaintext, *ciphertext;
3159         unsigned plaintext_pad_len;
3160         unsigned plaintext_len;
3161         struct rte_cryptodev_info dev_info;
3162
3163         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3164         uint64_t feat_flags = dev_info.feature_flags;
3165
3166         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3167                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3168                 printf("Device doesn't support RAW data-path APIs.\n");
3169                 return -ENOTSUP;
3170         }
3171
3172         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3173                 return -ENOTSUP;
3174
3175         /* Verify the capabilities */
3176         struct rte_cryptodev_sym_capability_idx cap_idx;
3177         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3178         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3179         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3180                         &cap_idx) == NULL)
3181                 return -ENOTSUP;
3182
3183         /* Create KASUMI session */
3184         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3185                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3186                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3187                                         tdata->key.data, tdata->key.len,
3188                                         tdata->cipher_iv.len);
3189         if (retval < 0)
3190                 return retval;
3191
3192         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3193
3194         /* Clear mbuf payload */
3195         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3196                rte_pktmbuf_tailroom(ut_params->ibuf));
3197
3198         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3199         /* Append data which is padded to a multiple */
3200         /* of the algorithms block size */
3201         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3202         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3203                                 plaintext_pad_len);
3204         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3205
3206         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3207
3208         /* Create KASUMI operation */
3209         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3210                                 tdata->cipher_iv.len,
3211                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3212                                 tdata->validCipherOffsetInBits.len);
3213         if (retval < 0)
3214                 return retval;
3215
3216         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3217                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3218                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3219         else
3220                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3221                                 ut_params->op);
3222         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3223
3224         ut_params->obuf = ut_params->op->sym->m_dst;
3225         if (ut_params->obuf)
3226                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3227         else
3228                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3229
3230         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3231
3232         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3233                                 (tdata->validCipherOffsetInBits.len >> 3);
3234         /* Validate obuf */
3235         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3236                 ciphertext,
3237                 reference_ciphertext,
3238                 tdata->validCipherLenInBits.len,
3239                 "KASUMI Ciphertext data not as expected");
3240         return 0;
3241 }
3242
3243 static int
3244 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3245 {
3246         struct crypto_testsuite_params *ts_params = &testsuite_params;
3247         struct crypto_unittest_params *ut_params = &unittest_params;
3248
3249         int retval;
3250
3251         unsigned int plaintext_pad_len;
3252         unsigned int plaintext_len;
3253
3254         uint8_t buffer[10000];
3255         const uint8_t *ciphertext;
3256
3257         struct rte_cryptodev_info dev_info;
3258
3259         /* Verify the capabilities */
3260         struct rte_cryptodev_sym_capability_idx cap_idx;
3261         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3262         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3263         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3264                         &cap_idx) == NULL)
3265                 return -ENOTSUP;
3266
3267         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3268
3269         uint64_t feat_flags = dev_info.feature_flags;
3270
3271         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3272                 printf("Device doesn't support in-place scatter-gather. "
3273                                 "Test Skipped.\n");
3274                 return -ENOTSUP;
3275         }
3276
3277         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3278                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3279                 printf("Device doesn't support RAW data-path APIs.\n");
3280                 return -ENOTSUP;
3281         }
3282
3283         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3284                 return -ENOTSUP;
3285
3286         /* Create KASUMI session */
3287         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3288                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3289                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3290                                         tdata->key.data, tdata->key.len,
3291                                         tdata->cipher_iv.len);
3292         if (retval < 0)
3293                 return retval;
3294
3295         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3296
3297
3298         /* Append data which is padded to a multiple */
3299         /* of the algorithms block size */
3300         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3301
3302         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3303                         plaintext_pad_len, 10, 0);
3304
3305         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3306
3307         /* Create KASUMI operation */
3308         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3309                                 tdata->cipher_iv.len,
3310                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3311                                 tdata->validCipherOffsetInBits.len);
3312         if (retval < 0)
3313                 return retval;
3314
3315         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3316                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3317                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3318         else
3319                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3320                                                 ut_params->op);
3321         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3322
3323         ut_params->obuf = ut_params->op->sym->m_dst;
3324
3325         if (ut_params->obuf)
3326                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3327                                 plaintext_len, buffer);
3328         else
3329                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3330                                 tdata->validCipherOffsetInBits.len >> 3,
3331                                 plaintext_len, buffer);
3332
3333         /* Validate obuf */
3334         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3335
3336         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3337                                 (tdata->validCipherOffsetInBits.len >> 3);
3338         /* Validate obuf */
3339         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3340                 ciphertext,
3341                 reference_ciphertext,
3342                 tdata->validCipherLenInBits.len,
3343                 "KASUMI Ciphertext data not as expected");
3344         return 0;
3345 }
3346
3347 static int
3348 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3349 {
3350         struct crypto_testsuite_params *ts_params = &testsuite_params;
3351         struct crypto_unittest_params *ut_params = &unittest_params;
3352
3353         int retval;
3354         uint8_t *plaintext, *ciphertext;
3355         unsigned plaintext_pad_len;
3356         unsigned plaintext_len;
3357
3358         /* Verify the capabilities */
3359         struct rte_cryptodev_sym_capability_idx cap_idx;
3360         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3361         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3362         /* Data-path service does not support OOP */
3363         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3364                         &cap_idx) == NULL)
3365                 return -ENOTSUP;
3366
3367         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3368                 return -ENOTSUP;
3369
3370         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3371                 return -ENOTSUP;
3372
3373         /* Create KASUMI session */
3374         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3375                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3376                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3377                                         tdata->key.data, tdata->key.len,
3378                                         tdata->cipher_iv.len);
3379         if (retval < 0)
3380                 return retval;
3381
3382         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3383         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3384
3385         /* Clear mbuf payload */
3386         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3387                rte_pktmbuf_tailroom(ut_params->ibuf));
3388
3389         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3390         /* Append data which is padded to a multiple */
3391         /* of the algorithms block size */
3392         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3393         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3394                                 plaintext_pad_len);
3395         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3396         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3397
3398         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3399
3400         /* Create KASUMI operation */
3401         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3402                                 tdata->cipher_iv.len,
3403                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3404                                 tdata->validCipherOffsetInBits.len);
3405         if (retval < 0)
3406                 return retval;
3407
3408         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3409                                                 ut_params->op);
3410         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3411
3412         ut_params->obuf = ut_params->op->sym->m_dst;
3413         if (ut_params->obuf)
3414                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3415         else
3416                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3417
3418         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3419
3420         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3421                                 (tdata->validCipherOffsetInBits.len >> 3);
3422         /* Validate obuf */
3423         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3424                 ciphertext,
3425                 reference_ciphertext,
3426                 tdata->validCipherLenInBits.len,
3427                 "KASUMI Ciphertext data not as expected");
3428         return 0;
3429 }
3430
3431 static int
3432 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3433 {
3434         struct crypto_testsuite_params *ts_params = &testsuite_params;
3435         struct crypto_unittest_params *ut_params = &unittest_params;
3436
3437         int retval;
3438         unsigned int plaintext_pad_len;
3439         unsigned int plaintext_len;
3440
3441         const uint8_t *ciphertext;
3442         uint8_t buffer[2048];
3443
3444         struct rte_cryptodev_info dev_info;
3445
3446         /* Verify the capabilities */
3447         struct rte_cryptodev_sym_capability_idx cap_idx;
3448         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3449         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3450         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3451                         &cap_idx) == NULL)
3452                 return -ENOTSUP;
3453
3454         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3455                 return -ENOTSUP;
3456
3457         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3458                 return -ENOTSUP;
3459
3460         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3461
3462         uint64_t feat_flags = dev_info.feature_flags;
3463         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3464                 printf("Device doesn't support out-of-place scatter-gather "
3465                                 "in both input and output mbufs. "
3466                                 "Test Skipped.\n");
3467                 return -ENOTSUP;
3468         }
3469
3470         /* Create KASUMI session */
3471         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3472                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3473                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3474                                         tdata->key.data, tdata->key.len,
3475                                         tdata->cipher_iv.len);
3476         if (retval < 0)
3477                 return retval;
3478
3479         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3480         /* Append data which is padded to a multiple */
3481         /* of the algorithms block size */
3482         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3483
3484         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3485                         plaintext_pad_len, 10, 0);
3486         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3487                         plaintext_pad_len, 3, 0);
3488
3489         /* Append data which is padded to a multiple */
3490         /* of the algorithms block size */
3491         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3492
3493         /* Create KASUMI operation */
3494         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3495                                 tdata->cipher_iv.len,
3496                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3497                                 tdata->validCipherOffsetInBits.len);
3498         if (retval < 0)
3499                 return retval;
3500
3501         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3502                                                 ut_params->op);
3503         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3504
3505         ut_params->obuf = ut_params->op->sym->m_dst;
3506         if (ut_params->obuf)
3507                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3508                                 plaintext_pad_len, buffer);
3509         else
3510                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3511                                 tdata->validCipherOffsetInBits.len >> 3,
3512                                 plaintext_pad_len, buffer);
3513
3514         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3515                                 (tdata->validCipherOffsetInBits.len >> 3);
3516         /* Validate obuf */
3517         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3518                 ciphertext,
3519                 reference_ciphertext,
3520                 tdata->validCipherLenInBits.len,
3521                 "KASUMI Ciphertext data not as expected");
3522         return 0;
3523 }
3524
3525
3526 static int
3527 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3528 {
3529         struct crypto_testsuite_params *ts_params = &testsuite_params;
3530         struct crypto_unittest_params *ut_params = &unittest_params;
3531
3532         int retval;
3533         uint8_t *ciphertext, *plaintext;
3534         unsigned ciphertext_pad_len;
3535         unsigned ciphertext_len;
3536
3537         /* Verify the capabilities */
3538         struct rte_cryptodev_sym_capability_idx cap_idx;
3539         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3540         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3541         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3542                         &cap_idx) == NULL)
3543                 return -ENOTSUP;
3544
3545         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3546                 return -ENOTSUP;
3547
3548         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3549                 return -ENOTSUP;
3550
3551         /* Create KASUMI session */
3552         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3553                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3554                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3555                                         tdata->key.data, tdata->key.len,
3556                                         tdata->cipher_iv.len);
3557         if (retval < 0)
3558                 return retval;
3559
3560         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3561         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3562
3563         /* Clear mbuf payload */
3564         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3565                rte_pktmbuf_tailroom(ut_params->ibuf));
3566
3567         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3568         /* Append data which is padded to a multiple */
3569         /* of the algorithms block size */
3570         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3571         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3572                                 ciphertext_pad_len);
3573         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3574         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3575
3576         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3577
3578         /* Create KASUMI operation */
3579         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3580                                 tdata->cipher_iv.len,
3581                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3582                                 tdata->validCipherOffsetInBits.len);
3583         if (retval < 0)
3584                 return retval;
3585
3586         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3587                                                 ut_params->op);
3588         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3589
3590         ut_params->obuf = ut_params->op->sym->m_dst;
3591         if (ut_params->obuf)
3592                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3593         else
3594                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3595
3596         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3597
3598         const uint8_t *reference_plaintext = tdata->plaintext.data +
3599                                 (tdata->validCipherOffsetInBits.len >> 3);
3600         /* Validate obuf */
3601         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3602                 plaintext,
3603                 reference_plaintext,
3604                 tdata->validCipherLenInBits.len,
3605                 "KASUMI Plaintext data not as expected");
3606         return 0;
3607 }
3608
3609 static int
3610 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3611 {
3612         struct crypto_testsuite_params *ts_params = &testsuite_params;
3613         struct crypto_unittest_params *ut_params = &unittest_params;
3614
3615         int retval;
3616         uint8_t *ciphertext, *plaintext;
3617         unsigned ciphertext_pad_len;
3618         unsigned ciphertext_len;
3619         struct rte_cryptodev_info dev_info;
3620
3621         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3622         uint64_t feat_flags = dev_info.feature_flags;
3623
3624         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3625                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3626                 printf("Device doesn't support RAW data-path APIs.\n");
3627                 return -ENOTSUP;
3628         }
3629
3630         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3631                 return -ENOTSUP;
3632
3633         /* Verify the capabilities */
3634         struct rte_cryptodev_sym_capability_idx cap_idx;
3635         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3636         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3637         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3638                         &cap_idx) == NULL)
3639                 return -ENOTSUP;
3640
3641         /* Create KASUMI session */
3642         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3643                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3644                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3645                                         tdata->key.data, tdata->key.len,
3646                                         tdata->cipher_iv.len);
3647         if (retval < 0)
3648                 return retval;
3649
3650         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3651
3652         /* Clear mbuf payload */
3653         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3654                rte_pktmbuf_tailroom(ut_params->ibuf));
3655
3656         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3657         /* Append data which is padded to a multiple */
3658         /* of the algorithms block size */
3659         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3660         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3661                                 ciphertext_pad_len);
3662         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3663
3664         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3665
3666         /* Create KASUMI operation */
3667         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3668                                         tdata->cipher_iv.len,
3669                                         tdata->ciphertext.len,
3670                                         tdata->validCipherOffsetInBits.len);
3671         if (retval < 0)
3672                 return retval;
3673
3674         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3675                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3676                                 ut_params->op, 1, 0, 1, 0);
3677         else
3678                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3679                                                 ut_params->op);
3680         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3681
3682         ut_params->obuf = ut_params->op->sym->m_dst;
3683         if (ut_params->obuf)
3684                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3685         else
3686                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3687
3688         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3689
3690         const uint8_t *reference_plaintext = tdata->plaintext.data +
3691                                 (tdata->validCipherOffsetInBits.len >> 3);
3692         /* Validate obuf */
3693         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3694                 plaintext,
3695                 reference_plaintext,
3696                 tdata->validCipherLenInBits.len,
3697                 "KASUMI Plaintext data not as expected");
3698         return 0;
3699 }
3700
3701 static int
3702 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3703 {
3704         struct crypto_testsuite_params *ts_params = &testsuite_params;
3705         struct crypto_unittest_params *ut_params = &unittest_params;
3706
3707         int retval;
3708         uint8_t *plaintext, *ciphertext;
3709         unsigned plaintext_pad_len;
3710         unsigned plaintext_len;
3711         struct rte_cryptodev_info dev_info;
3712
3713         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3714         uint64_t feat_flags = dev_info.feature_flags;
3715
3716         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3717                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3718                 printf("Device doesn't support RAW data-path APIs.\n");
3719                 return -ENOTSUP;
3720         }
3721
3722         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3723                 return -ENOTSUP;
3724
3725         /* Verify the capabilities */
3726         struct rte_cryptodev_sym_capability_idx cap_idx;
3727         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3728         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3729         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3730                         &cap_idx) == NULL)
3731                 return -ENOTSUP;
3732
3733         /* Create SNOW 3G session */
3734         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3735                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3736                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3737                                         tdata->key.data, tdata->key.len,
3738                                         tdata->cipher_iv.len);
3739         if (retval < 0)
3740                 return retval;
3741
3742         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3743
3744         /* Clear mbuf payload */
3745         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3746                rte_pktmbuf_tailroom(ut_params->ibuf));
3747
3748         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3749         /* Append data which is padded to a multiple of */
3750         /* the algorithms block size */
3751         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3752         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3753                                 plaintext_pad_len);
3754         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3755
3756         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3757
3758         /* Create SNOW 3G operation */
3759         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760                                         tdata->cipher_iv.len,
3761                                         tdata->validCipherLenInBits.len,
3762                                         0);
3763         if (retval < 0)
3764                 return retval;
3765
3766         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3767                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3768                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3769         else
3770                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3771                                                 ut_params->op);
3772         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3773
3774         ut_params->obuf = ut_params->op->sym->m_dst;
3775         if (ut_params->obuf)
3776                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3777         else
3778                 ciphertext = plaintext;
3779
3780         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3781
3782         /* Validate obuf */
3783         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3784                 ciphertext,
3785                 tdata->ciphertext.data,
3786                 tdata->validDataLenInBits.len,
3787                 "SNOW 3G Ciphertext data not as expected");
3788         return 0;
3789 }
3790
3791
3792 static int
3793 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3794 {
3795         struct crypto_testsuite_params *ts_params = &testsuite_params;
3796         struct crypto_unittest_params *ut_params = &unittest_params;
3797         uint8_t *plaintext, *ciphertext;
3798
3799         int retval;
3800         unsigned plaintext_pad_len;
3801         unsigned plaintext_len;
3802
3803         /* Verify the capabilities */
3804         struct rte_cryptodev_sym_capability_idx cap_idx;
3805         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3806         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3807         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3808                         &cap_idx) == NULL)
3809                 return -ENOTSUP;
3810
3811         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3812                 return -ENOTSUP;
3813
3814         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3815                 return -ENOTSUP;
3816
3817         /* Create SNOW 3G session */
3818         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3819                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3820                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3821                                         tdata->key.data, tdata->key.len,
3822                                         tdata->cipher_iv.len);
3823         if (retval < 0)
3824                 return retval;
3825
3826         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3827         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3828
3829         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3830                         "Failed to allocate input buffer in mempool");
3831         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3832                         "Failed to allocate output buffer in mempool");
3833
3834         /* Clear mbuf payload */
3835         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3836                rte_pktmbuf_tailroom(ut_params->ibuf));
3837
3838         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3839         /* Append data which is padded to a multiple of */
3840         /* the algorithms block size */
3841         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3842         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3843                                 plaintext_pad_len);
3844         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3845         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3846
3847         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3848
3849         /* Create SNOW 3G operation */
3850         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3851                                         tdata->cipher_iv.len,
3852                                         tdata->validCipherLenInBits.len,
3853                                         0);
3854         if (retval < 0)
3855                 return retval;
3856
3857         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3858                                                 ut_params->op);
3859         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3860
3861         ut_params->obuf = ut_params->op->sym->m_dst;
3862         if (ut_params->obuf)
3863                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3864         else
3865                 ciphertext = plaintext;
3866
3867         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3868
3869         /* Validate obuf */
3870         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3871                 ciphertext,
3872                 tdata->ciphertext.data,
3873                 tdata->validDataLenInBits.len,
3874                 "SNOW 3G Ciphertext data not as expected");
3875         return 0;
3876 }
3877
3878 static int
3879 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3880 {
3881         struct crypto_testsuite_params *ts_params = &testsuite_params;
3882         struct crypto_unittest_params *ut_params = &unittest_params;
3883
3884         int retval;
3885         unsigned int plaintext_pad_len;
3886         unsigned int plaintext_len;
3887         uint8_t buffer[10000];
3888         const uint8_t *ciphertext;
3889
3890         struct rte_cryptodev_info dev_info;
3891
3892         /* Verify the capabilities */
3893         struct rte_cryptodev_sym_capability_idx cap_idx;
3894         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3895         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3896         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3897                         &cap_idx) == NULL)
3898                 return -ENOTSUP;
3899
3900         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3901                 return -ENOTSUP;
3902
3903         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3904                 return -ENOTSUP;
3905
3906         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3907
3908         uint64_t feat_flags = dev_info.feature_flags;
3909
3910         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3911                 printf("Device doesn't support out-of-place scatter-gather "
3912                                 "in both input and output mbufs. "
3913                                 "Test Skipped.\n");
3914                 return -ENOTSUP;
3915         }
3916
3917         /* Create SNOW 3G session */
3918         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3919                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3920                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3921                                         tdata->key.data, tdata->key.len,
3922                                         tdata->cipher_iv.len);
3923         if (retval < 0)
3924                 return retval;
3925
3926         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3927         /* Append data which is padded to a multiple of */
3928         /* the algorithms block size */
3929         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3930
3931         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3932                         plaintext_pad_len, 10, 0);
3933         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3934                         plaintext_pad_len, 3, 0);
3935
3936         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3937                         "Failed to allocate input buffer in mempool");
3938         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3939                         "Failed to allocate output buffer in mempool");
3940
3941         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3942
3943         /* Create SNOW 3G operation */
3944         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3945                                         tdata->cipher_iv.len,
3946                                         tdata->validCipherLenInBits.len,
3947                                         0);
3948         if (retval < 0)
3949                 return retval;
3950
3951         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3952                                                 ut_params->op);
3953         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3954
3955         ut_params->obuf = ut_params->op->sym->m_dst;
3956         if (ut_params->obuf)
3957                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3958                                 plaintext_len, buffer);
3959         else
3960                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3961                                 plaintext_len, buffer);
3962
3963         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3964
3965         /* Validate obuf */
3966         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3967                 ciphertext,
3968                 tdata->ciphertext.data,
3969                 tdata->validDataLenInBits.len,
3970                 "SNOW 3G Ciphertext data not as expected");
3971
3972         return 0;
3973 }
3974
3975 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3976 static void
3977 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3978 {
3979         uint8_t curr_byte, prev_byte;
3980         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3981         uint8_t lower_byte_mask = (1 << offset) - 1;
3982         unsigned i;
3983
3984         prev_byte = buffer[0];
3985         buffer[0] >>= offset;
3986
3987         for (i = 1; i < length_in_bytes; i++) {
3988                 curr_byte = buffer[i];
3989                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3990                                 (curr_byte >> offset);
3991                 prev_byte = curr_byte;
3992         }
3993 }
3994
3995 static int
3996 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3997 {
3998         struct crypto_testsuite_params *ts_params = &testsuite_params;
3999         struct crypto_unittest_params *ut_params = &unittest_params;
4000         uint8_t *plaintext, *ciphertext;
4001         int retval;
4002         uint32_t plaintext_len;
4003         uint32_t plaintext_pad_len;
4004         uint8_t extra_offset = 4;
4005         uint8_t *expected_ciphertext_shifted;
4006         struct rte_cryptodev_info dev_info;
4007
4008         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4009         uint64_t feat_flags = dev_info.feature_flags;
4010
4011         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4012                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4013                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4014                 return -ENOTSUP;
4015         }
4016
4017         /* Verify the capabilities */
4018         struct rte_cryptodev_sym_capability_idx cap_idx;
4019         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4020         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4021         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4022                         &cap_idx) == NULL)
4023                 return -ENOTSUP;
4024
4025         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4026                 return -ENOTSUP;
4027
4028         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4029                 return -ENOTSUP;
4030
4031         /* Create SNOW 3G session */
4032         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4033                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4034                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4035                                         tdata->key.data, tdata->key.len,
4036                                         tdata->cipher_iv.len);
4037         if (retval < 0)
4038                 return retval;
4039
4040         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4041         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4042
4043         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4044                         "Failed to allocate input buffer in mempool");
4045         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4046                         "Failed to allocate output buffer in mempool");
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         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4053         /*
4054          * Append data which is padded to a
4055          * multiple of the algorithms block size
4056          */
4057         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4058
4059         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4060                                                 plaintext_pad_len);
4061
4062         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4063
4064         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4065         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4066
4067 #ifdef RTE_APP_TEST_DEBUG
4068         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4069 #endif
4070         /* Create SNOW 3G operation */
4071         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4072                                         tdata->cipher_iv.len,
4073                                         tdata->validCipherLenInBits.len,
4074                                         extra_offset);
4075         if (retval < 0)
4076                 return retval;
4077
4078         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4079                                                 ut_params->op);
4080         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4081
4082         ut_params->obuf = ut_params->op->sym->m_dst;
4083         if (ut_params->obuf)
4084                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4085         else
4086                 ciphertext = plaintext;
4087
4088 #ifdef RTE_APP_TEST_DEBUG
4089         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4090 #endif
4091
4092         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4093
4094         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4095                         "failed to reserve memory for ciphertext shifted\n");
4096
4097         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4098                         ceil_byte_length(tdata->ciphertext.len));
4099         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4100                         extra_offset);
4101         /* Validate obuf */
4102         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4103                 ciphertext,
4104                 expected_ciphertext_shifted,
4105                 tdata->validDataLenInBits.len,
4106                 extra_offset,
4107                 "SNOW 3G Ciphertext data not as expected");
4108         return 0;
4109 }
4110
4111 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4112 {
4113         struct crypto_testsuite_params *ts_params = &testsuite_params;
4114         struct crypto_unittest_params *ut_params = &unittest_params;
4115
4116         int retval;
4117
4118         uint8_t *plaintext, *ciphertext;
4119         unsigned ciphertext_pad_len;
4120         unsigned ciphertext_len;
4121         struct rte_cryptodev_info dev_info;
4122
4123         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4124         uint64_t feat_flags = dev_info.feature_flags;
4125
4126         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4127                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4128                 printf("Device doesn't support RAW data-path APIs.\n");
4129                 return -ENOTSUP;
4130         }
4131
4132         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4133                 return -ENOTSUP;
4134
4135         /* Verify the capabilities */
4136         struct rte_cryptodev_sym_capability_idx cap_idx;
4137         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4138         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4139         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4140                         &cap_idx) == NULL)
4141                 return -ENOTSUP;
4142
4143         /* Create SNOW 3G session */
4144         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4145                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4146                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4147                                         tdata->key.data, tdata->key.len,
4148                                         tdata->cipher_iv.len);
4149         if (retval < 0)
4150                 return retval;
4151
4152         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4153
4154         /* Clear mbuf payload */
4155         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4156                rte_pktmbuf_tailroom(ut_params->ibuf));
4157
4158         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4159         /* Append data which is padded to a multiple of */
4160         /* the algorithms block size */
4161         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4162         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4163                                 ciphertext_pad_len);
4164         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4165
4166         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4167
4168         /* Create SNOW 3G operation */
4169         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4170                                         tdata->cipher_iv.len,
4171                                         tdata->validCipherLenInBits.len,
4172                                         tdata->cipher.offset_bits);
4173         if (retval < 0)
4174                 return retval;
4175
4176         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4177                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4178                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4179         else
4180                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4181                                                 ut_params->op);
4182         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4183         ut_params->obuf = ut_params->op->sym->m_dst;
4184         if (ut_params->obuf)
4185                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4186         else
4187                 plaintext = ciphertext;
4188
4189         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4190
4191         /* Validate obuf */
4192         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4193                                 tdata->plaintext.data,
4194                                 tdata->validDataLenInBits.len,
4195                                 "SNOW 3G Plaintext data not as expected");
4196         return 0;
4197 }
4198
4199 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4200 {
4201         struct crypto_testsuite_params *ts_params = &testsuite_params;
4202         struct crypto_unittest_params *ut_params = &unittest_params;
4203
4204         int retval;
4205
4206         uint8_t *plaintext, *ciphertext;
4207         unsigned ciphertext_pad_len;
4208         unsigned ciphertext_len;
4209
4210         /* Verify the capabilities */
4211         struct rte_cryptodev_sym_capability_idx cap_idx;
4212         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4213         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4214         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4215                         &cap_idx) == NULL)
4216                 return -ENOTSUP;
4217
4218         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4219                 return -ENOTSUP;
4220
4221         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4222                 return -ENOTSUP;
4223
4224         /* Create SNOW 3G session */
4225         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4226                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4227                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4228                                         tdata->key.data, tdata->key.len,
4229                                         tdata->cipher_iv.len);
4230         if (retval < 0)
4231                 return retval;
4232
4233         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4234         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4235
4236         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4237                         "Failed to allocate input buffer");
4238         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4239                         "Failed to allocate output buffer");
4240
4241         /* Clear mbuf payload */
4242         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4243                rte_pktmbuf_tailroom(ut_params->ibuf));
4244
4245         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4246                        rte_pktmbuf_tailroom(ut_params->obuf));
4247
4248         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4249         /* Append data which is padded to a multiple of */
4250         /* the algorithms block size */
4251         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4252         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4253                                 ciphertext_pad_len);
4254         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4255         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4256
4257         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4258
4259         /* Create SNOW 3G operation */
4260         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4261                                         tdata->cipher_iv.len,
4262                                         tdata->validCipherLenInBits.len,
4263                                         0);
4264         if (retval < 0)
4265                 return retval;
4266
4267         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4268                                                 ut_params->op);
4269         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4270         ut_params->obuf = ut_params->op->sym->m_dst;
4271         if (ut_params->obuf)
4272                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4273         else
4274                 plaintext = ciphertext;
4275
4276         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4277
4278         /* Validate obuf */
4279         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4280                                 tdata->plaintext.data,
4281                                 tdata->validDataLenInBits.len,
4282                                 "SNOW 3G Plaintext data not as expected");
4283         return 0;
4284 }
4285
4286 static int
4287 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4288 {
4289         struct crypto_testsuite_params *ts_params = &testsuite_params;
4290         struct crypto_unittest_params *ut_params = &unittest_params;
4291
4292         int retval;
4293
4294         uint8_t *plaintext, *ciphertext;
4295         unsigned int plaintext_pad_len;
4296         unsigned int plaintext_len;
4297
4298         struct rte_cryptodev_info dev_info;
4299         struct rte_cryptodev_sym_capability_idx cap_idx;
4300
4301         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4302         uint64_t feat_flags = dev_info.feature_flags;
4303
4304         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4305                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4306                         (tdata->validDataLenInBits.len % 8 != 0))) {
4307                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4308                 return -ENOTSUP;
4309         }
4310
4311         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4312                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4313                 printf("Device doesn't support RAW data-path APIs.\n");
4314                 return -ENOTSUP;
4315         }
4316
4317         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4318                 return -ENOTSUP;
4319
4320         /* Check if device supports ZUC EEA3 */
4321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4322         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4323
4324         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4325                         &cap_idx) == NULL)
4326                 return -ENOTSUP;
4327
4328         /* Check if device supports ZUC EIA3 */
4329         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4330         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4331
4332         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4333                         &cap_idx) == NULL)
4334                 return -ENOTSUP;
4335
4336         /* Create ZUC session */
4337         retval = create_zuc_cipher_auth_encrypt_generate_session(
4338                         ts_params->valid_devs[0],
4339                         tdata);
4340         if (retval < 0)
4341                 return retval;
4342         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4343
4344         /* clear mbuf payload */
4345         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4346                         rte_pktmbuf_tailroom(ut_params->ibuf));
4347
4348         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4349         /* Append data which is padded to a multiple of */
4350         /* the algorithms block size */
4351         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4352         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4353                                 plaintext_pad_len);
4354         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4355
4356         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4357
4358         /* Create ZUC operation */
4359         retval = create_zuc_cipher_hash_generate_operation(tdata);
4360         if (retval < 0)
4361                 return retval;
4362
4363         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4364                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4365                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4366         else
4367                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4368                         ut_params->op);
4369         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4370         ut_params->obuf = ut_params->op->sym->m_src;
4371         if (ut_params->obuf)
4372                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4373         else
4374                 ciphertext = plaintext;
4375
4376         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4377         /* Validate obuf */
4378         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4379                         ciphertext,
4380                         tdata->ciphertext.data,
4381                         tdata->validDataLenInBits.len,
4382                         "ZUC Ciphertext data not as expected");
4383
4384         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4385             + plaintext_pad_len;
4386
4387         /* Validate obuf */
4388         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4389                         ut_params->digest,
4390                         tdata->digest.data,
4391                         4,
4392                         "ZUC Generated auth tag not as expected");
4393         return 0;
4394 }
4395
4396 static int
4397 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4398 {
4399         struct crypto_testsuite_params *ts_params = &testsuite_params;
4400         struct crypto_unittest_params *ut_params = &unittest_params;
4401
4402         int retval;
4403
4404         uint8_t *plaintext, *ciphertext;
4405         unsigned plaintext_pad_len;
4406         unsigned plaintext_len;
4407         struct rte_cryptodev_info dev_info;
4408
4409         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4410         uint64_t feat_flags = dev_info.feature_flags;
4411
4412         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4413                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4414                 printf("Device doesn't support RAW data-path APIs.\n");
4415                 return -ENOTSUP;
4416         }
4417
4418         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4419                 return -ENOTSUP;
4420
4421         /* Verify the capabilities */
4422         struct rte_cryptodev_sym_capability_idx cap_idx;
4423         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4424         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4425         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4426                         &cap_idx) == NULL)
4427                 return -ENOTSUP;
4428         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4429         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4430         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4431                         &cap_idx) == NULL)
4432                 return -ENOTSUP;
4433
4434         /* Create SNOW 3G session */
4435         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4436                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4437                         RTE_CRYPTO_AUTH_OP_GENERATE,
4438                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4439                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4440                         tdata->key.data, tdata->key.len,
4441                         tdata->auth_iv.len, tdata->digest.len,
4442                         tdata->cipher_iv.len);
4443         if (retval < 0)
4444                 return retval;
4445         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4446
4447         /* clear mbuf payload */
4448         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4449                         rte_pktmbuf_tailroom(ut_params->ibuf));
4450
4451         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4452         /* Append data which is padded to a multiple of */
4453         /* the algorithms block size */
4454         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4455         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4456                                 plaintext_pad_len);
4457         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4458
4459         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4460
4461         /* Create SNOW 3G operation */
4462         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4463                         tdata->digest.len, tdata->auth_iv.data,
4464                         tdata->auth_iv.len,
4465                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4466                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4467                         tdata->validCipherLenInBits.len,
4468                         0,
4469                         tdata->validAuthLenInBits.len,
4470                         0
4471                         );
4472         if (retval < 0)
4473                 return retval;
4474
4475         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4476                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4477                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4478         else
4479                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4480                         ut_params->op);
4481         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4482         ut_params->obuf = ut_params->op->sym->m_src;
4483         if (ut_params->obuf)
4484                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4485         else
4486                 ciphertext = plaintext;
4487
4488         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4489         /* Validate obuf */
4490         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4491                         ciphertext,
4492                         tdata->ciphertext.data,
4493                         tdata->validDataLenInBits.len,
4494                         "SNOW 3G Ciphertext data not as expected");
4495
4496         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4497             + plaintext_pad_len;
4498
4499         /* Validate obuf */
4500         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4501                         ut_params->digest,
4502                         tdata->digest.data,
4503                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4504                         "SNOW 3G Generated auth tag not as expected");
4505         return 0;
4506 }
4507
4508 static int
4509 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4510         uint8_t op_mode, uint8_t verify)
4511 {
4512         struct crypto_testsuite_params *ts_params = &testsuite_params;
4513         struct crypto_unittest_params *ut_params = &unittest_params;
4514
4515         int retval;
4516
4517         uint8_t *plaintext = NULL, *ciphertext = NULL;
4518         unsigned int plaintext_pad_len;
4519         unsigned int plaintext_len;
4520         unsigned int ciphertext_pad_len;
4521         unsigned int ciphertext_len;
4522
4523         struct rte_cryptodev_info dev_info;
4524
4525         /* Verify the capabilities */
4526         struct rte_cryptodev_sym_capability_idx cap_idx;
4527         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4528         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4529         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4530                         &cap_idx) == NULL)
4531                 return -ENOTSUP;
4532         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4533         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4534         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4535                         &cap_idx) == NULL)
4536                 return -ENOTSUP;
4537
4538         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4539                 return -ENOTSUP;
4540
4541         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4542
4543         uint64_t feat_flags = dev_info.feature_flags;
4544
4545         if (op_mode == OUT_OF_PLACE) {
4546                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4547                         printf("Device doesn't support digest encrypted.\n");
4548                         return -ENOTSUP;
4549                 }
4550                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4551                         return -ENOTSUP;
4552         }
4553
4554         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4555                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4556                 printf("Device doesn't support RAW data-path APIs.\n");
4557                 return -ENOTSUP;
4558         }
4559
4560         /* Create SNOW 3G session */
4561         retval = create_wireless_algo_auth_cipher_session(
4562                         ts_params->valid_devs[0],
4563                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4564                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4565                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4566                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4567                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4568                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4569                         tdata->key.data, tdata->key.len,
4570                         tdata->auth_iv.len, tdata->digest.len,
4571                         tdata->cipher_iv.len);
4572
4573         if (retval < 0)
4574                 return retval;
4575
4576         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4577         if (op_mode == OUT_OF_PLACE)
4578                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4579
4580         /* clear mbuf payload */
4581         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4582                 rte_pktmbuf_tailroom(ut_params->ibuf));
4583         if (op_mode == OUT_OF_PLACE)
4584                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4585                         rte_pktmbuf_tailroom(ut_params->obuf));
4586
4587         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4588         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4589         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4590         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4591
4592         if (verify) {
4593                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4594                                         ciphertext_pad_len);
4595                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4596                 if (op_mode == OUT_OF_PLACE)
4597                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4598                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4599                         ciphertext_len);
4600         } else {
4601                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4602                                         plaintext_pad_len);
4603                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4604                 if (op_mode == OUT_OF_PLACE)
4605                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4606                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4607         }
4608
4609         /* Create SNOW 3G operation */
4610         retval = create_wireless_algo_auth_cipher_operation(
4611                 tdata->digest.data, tdata->digest.len,
4612                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4613                 tdata->auth_iv.data, tdata->auth_iv.len,
4614                 (tdata->digest.offset_bytes == 0 ?
4615                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4616                         : tdata->digest.offset_bytes),
4617                 tdata->validCipherLenInBits.len,
4618                 tdata->cipher.offset_bits,
4619                 tdata->validAuthLenInBits.len,
4620                 tdata->auth.offset_bits,
4621                 op_mode, 0, verify);
4622
4623         if (retval < 0)
4624                 return retval;
4625
4626         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4627                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4628                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4629         else
4630                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4631                         ut_params->op);
4632
4633         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4634
4635         ut_params->obuf = (op_mode == IN_PLACE ?
4636                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4637
4638         if (verify) {
4639                 if (ut_params->obuf)
4640                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4641                                                         uint8_t *);
4642                 else
4643                         plaintext = ciphertext +
4644                                 (tdata->cipher.offset_bits >> 3);
4645
4646                 debug_hexdump(stdout, "plaintext:", plaintext,
4647                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4648                 debug_hexdump(stdout, "plaintext expected:",
4649                         tdata->plaintext.data,
4650                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4651         } else {
4652                 if (ut_params->obuf)
4653                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4654                                                         uint8_t *);
4655                 else
4656                         ciphertext = plaintext;
4657
4658                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4659                         ciphertext_len);
4660                 debug_hexdump(stdout, "ciphertext expected:",
4661                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4662
4663                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4664                         + (tdata->digest.offset_bytes == 0 ?
4665                 plaintext_pad_len : tdata->digest.offset_bytes);
4666
4667                 debug_hexdump(stdout, "digest:", ut_params->digest,
4668                         tdata->digest.len);
4669                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4670                                 tdata->digest.len);
4671         }
4672
4673         /* Validate obuf */
4674         if (verify) {
4675                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4676                         plaintext,
4677                         tdata->plaintext.data,
4678                         tdata->plaintext.len >> 3,
4679                         "SNOW 3G Plaintext data not as expected");
4680         } else {
4681                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4682                         ciphertext,
4683                         tdata->ciphertext.data,
4684                         tdata->validDataLenInBits.len,
4685                         "SNOW 3G Ciphertext data not as expected");
4686
4687                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4688                         ut_params->digest,
4689                         tdata->digest.data,
4690                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4691                         "SNOW 3G Generated auth tag not as expected");
4692         }
4693         return 0;
4694 }
4695
4696 static int
4697 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4698         uint8_t op_mode, uint8_t verify)
4699 {
4700         struct crypto_testsuite_params *ts_params = &testsuite_params;
4701         struct crypto_unittest_params *ut_params = &unittest_params;
4702
4703         int retval;
4704
4705         const uint8_t *plaintext = NULL;
4706         const uint8_t *ciphertext = NULL;
4707         const uint8_t *digest = NULL;
4708         unsigned int plaintext_pad_len;
4709         unsigned int plaintext_len;
4710         unsigned int ciphertext_pad_len;
4711         unsigned int ciphertext_len;
4712         uint8_t buffer[10000];
4713         uint8_t digest_buffer[10000];
4714
4715         struct rte_cryptodev_info dev_info;
4716
4717         /* Verify the capabilities */
4718         struct rte_cryptodev_sym_capability_idx cap_idx;
4719         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4720         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4721         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4722                         &cap_idx) == NULL)
4723                 return -ENOTSUP;
4724         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4725         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4726         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4727                         &cap_idx) == NULL)
4728                 return -ENOTSUP;
4729
4730         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4731                 return -ENOTSUP;
4732
4733         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4734
4735         uint64_t feat_flags = dev_info.feature_flags;
4736
4737         if (op_mode == IN_PLACE) {
4738                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4739                         printf("Device doesn't support in-place scatter-gather "
4740                                         "in both input and output mbufs.\n");
4741                         return -ENOTSUP;
4742                 }
4743                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4744                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4745                         printf("Device doesn't support RAW data-path APIs.\n");
4746                         return -ENOTSUP;
4747                 }
4748         } else {
4749                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4750                         return -ENOTSUP;
4751                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4752                         printf("Device doesn't support out-of-place scatter-gather "
4753                                         "in both input and output mbufs.\n");
4754                         return -ENOTSUP;
4755                 }
4756                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4757                         printf("Device doesn't support digest encrypted.\n");
4758                         return -ENOTSUP;
4759                 }
4760         }
4761
4762         /* Create SNOW 3G session */
4763         retval = create_wireless_algo_auth_cipher_session(
4764                         ts_params->valid_devs[0],
4765                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4766                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4767                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4768                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4769                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4770                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4771                         tdata->key.data, tdata->key.len,
4772                         tdata->auth_iv.len, tdata->digest.len,
4773                         tdata->cipher_iv.len);
4774
4775         if (retval < 0)
4776                 return retval;
4777
4778         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4779         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4780         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4781         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4782
4783         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4784                         plaintext_pad_len, 15, 0);
4785         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4786                         "Failed to allocate input buffer in mempool");
4787
4788         if (op_mode == OUT_OF_PLACE) {
4789                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4790                                 plaintext_pad_len, 15, 0);
4791                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4792                                 "Failed to allocate output buffer in mempool");
4793         }
4794
4795         if (verify) {
4796                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4797                         tdata->ciphertext.data);
4798                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4799                                         ciphertext_len, buffer);
4800                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4801                         ciphertext_len);
4802         } else {
4803                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4804                         tdata->plaintext.data);
4805                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4806                                         plaintext_len, buffer);
4807                 debug_hexdump(stdout, "plaintext:", plaintext,
4808                         plaintext_len);
4809         }
4810         memset(buffer, 0, sizeof(buffer));
4811
4812         /* Create SNOW 3G operation */
4813         retval = create_wireless_algo_auth_cipher_operation(
4814                 tdata->digest.data, tdata->digest.len,
4815                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4816                 tdata->auth_iv.data, tdata->auth_iv.len,
4817                 (tdata->digest.offset_bytes == 0 ?
4818                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4819                         : tdata->digest.offset_bytes),
4820                 tdata->validCipherLenInBits.len,
4821                 tdata->cipher.offset_bits,
4822                 tdata->validAuthLenInBits.len,
4823                 tdata->auth.offset_bits,
4824                 op_mode, 1, verify);
4825
4826         if (retval < 0)
4827                 return retval;
4828
4829         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4830                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4831                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4832         else
4833                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4834                         ut_params->op);
4835
4836         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4837
4838         ut_params->obuf = (op_mode == IN_PLACE ?
4839                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4840
4841         if (verify) {
4842                 if (ut_params->obuf)
4843                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4844                                         plaintext_len, buffer);
4845                 else
4846                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4847                                         plaintext_len, buffer);
4848
4849                 debug_hexdump(stdout, "plaintext:", plaintext,
4850                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4851                 debug_hexdump(stdout, "plaintext expected:",
4852                         tdata->plaintext.data,
4853                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4854         } else {
4855                 if (ut_params->obuf)
4856                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4857                                         ciphertext_len, buffer);
4858                 else
4859                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4860                                         ciphertext_len, buffer);
4861
4862                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4863                         ciphertext_len);
4864                 debug_hexdump(stdout, "ciphertext expected:",
4865                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4866
4867                 if (ut_params->obuf)
4868                         digest = rte_pktmbuf_read(ut_params->obuf,
4869                                 (tdata->digest.offset_bytes == 0 ?
4870                                 plaintext_pad_len : tdata->digest.offset_bytes),
4871                                 tdata->digest.len, digest_buffer);
4872                 else
4873                         digest = rte_pktmbuf_read(ut_params->ibuf,
4874                                 (tdata->digest.offset_bytes == 0 ?
4875                                 plaintext_pad_len : tdata->digest.offset_bytes),
4876                                 tdata->digest.len, digest_buffer);
4877
4878                 debug_hexdump(stdout, "digest:", digest,
4879                         tdata->digest.len);
4880                 debug_hexdump(stdout, "digest expected:",
4881                         tdata->digest.data, tdata->digest.len);
4882         }
4883
4884         /* Validate obuf */
4885         if (verify) {
4886                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4887                         plaintext,
4888                         tdata->plaintext.data,
4889                         tdata->plaintext.len >> 3,
4890                         "SNOW 3G Plaintext data not as expected");
4891         } else {
4892                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4893                         ciphertext,
4894                         tdata->ciphertext.data,
4895                         tdata->validDataLenInBits.len,
4896                         "SNOW 3G Ciphertext data not as expected");
4897
4898                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4899                         digest,
4900                         tdata->digest.data,
4901                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4902                         "SNOW 3G Generated auth tag not as expected");
4903         }
4904         return 0;
4905 }
4906
4907 static int
4908 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4909         uint8_t op_mode, uint8_t verify)
4910 {
4911         struct crypto_testsuite_params *ts_params = &testsuite_params;
4912         struct crypto_unittest_params *ut_params = &unittest_params;
4913
4914         int retval;
4915
4916         uint8_t *plaintext = NULL, *ciphertext = NULL;
4917         unsigned int plaintext_pad_len;
4918         unsigned int plaintext_len;
4919         unsigned int ciphertext_pad_len;
4920         unsigned int ciphertext_len;
4921
4922         struct rte_cryptodev_info dev_info;
4923
4924         /* Verify the capabilities */
4925         struct rte_cryptodev_sym_capability_idx cap_idx;
4926         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4927         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4928         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4929                         &cap_idx) == NULL)
4930                 return -ENOTSUP;
4931         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4932         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4933         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4934                         &cap_idx) == NULL)
4935                 return -ENOTSUP;
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 ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4942                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4943                 printf("Device doesn't support RAW data-path APIs.\n");
4944                 return -ENOTSUP;
4945         }
4946
4947         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4948                 return -ENOTSUP;
4949
4950         if (op_mode == OUT_OF_PLACE) {
4951                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4952                         return -ENOTSUP;
4953                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4954                         printf("Device doesn't support digest encrypted.\n");
4955                         return -ENOTSUP;
4956                 }
4957         }
4958
4959         /* Create KASUMI session */
4960         retval = create_wireless_algo_auth_cipher_session(
4961                         ts_params->valid_devs[0],
4962                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4963                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4964                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4965                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4966                         RTE_CRYPTO_AUTH_KASUMI_F9,
4967                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4968                         tdata->key.data, tdata->key.len,
4969                         0, tdata->digest.len,
4970                         tdata->cipher_iv.len);
4971
4972         if (retval < 0)
4973                 return retval;
4974
4975         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4976         if (op_mode == OUT_OF_PLACE)
4977                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4978
4979         /* clear mbuf payload */
4980         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4981                 rte_pktmbuf_tailroom(ut_params->ibuf));
4982         if (op_mode == OUT_OF_PLACE)
4983                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4984                         rte_pktmbuf_tailroom(ut_params->obuf));
4985
4986         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4987         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4988         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4989         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4990
4991         if (verify) {
4992                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4993                                         ciphertext_pad_len);
4994                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4995                 if (op_mode == OUT_OF_PLACE)
4996                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4997                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4998                         ciphertext_len);
4999         } else {
5000                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5001                                         plaintext_pad_len);
5002                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5003                 if (op_mode == OUT_OF_PLACE)
5004                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5005                 debug_hexdump(stdout, "plaintext:", plaintext,
5006                         plaintext_len);
5007         }
5008
5009         /* Create KASUMI operation */
5010         retval = create_wireless_algo_auth_cipher_operation(
5011                 tdata->digest.data, tdata->digest.len,
5012                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5013                 NULL, 0,
5014                 (tdata->digest.offset_bytes == 0 ?
5015                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5016                         : tdata->digest.offset_bytes),
5017                 tdata->validCipherLenInBits.len,
5018                 tdata->validCipherOffsetInBits.len,
5019                 tdata->validAuthLenInBits.len,
5020                 0,
5021                 op_mode, 0, verify);
5022
5023         if (retval < 0)
5024                 return retval;
5025
5026         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5027                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5028                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5029         else
5030                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5031                         ut_params->op);
5032
5033         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5034
5035         ut_params->obuf = (op_mode == IN_PLACE ?
5036                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5037
5038
5039         if (verify) {
5040                 if (ut_params->obuf)
5041                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5042                                                         uint8_t *);
5043                 else
5044                         plaintext = ciphertext;
5045
5046                 debug_hexdump(stdout, "plaintext:", plaintext,
5047                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5048                 debug_hexdump(stdout, "plaintext expected:",
5049                         tdata->plaintext.data,
5050                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5051         } else {
5052                 if (ut_params->obuf)
5053                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5054                                                         uint8_t *);
5055                 else
5056                         ciphertext = plaintext;
5057
5058                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5059                         ciphertext_len);
5060                 debug_hexdump(stdout, "ciphertext expected:",
5061                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5062
5063                 ut_params->digest = rte_pktmbuf_mtod(
5064                         ut_params->obuf, uint8_t *) +
5065                         (tdata->digest.offset_bytes == 0 ?
5066                         plaintext_pad_len : tdata->digest.offset_bytes);
5067
5068                 debug_hexdump(stdout, "digest:", ut_params->digest,
5069                         tdata->digest.len);
5070                 debug_hexdump(stdout, "digest expected:",
5071                         tdata->digest.data, tdata->digest.len);
5072         }
5073
5074         /* Validate obuf */
5075         if (verify) {
5076                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5077                         plaintext,
5078                         tdata->plaintext.data,
5079                         tdata->plaintext.len >> 3,
5080                         "KASUMI Plaintext data not as expected");
5081         } else {
5082                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5083                         ciphertext,
5084                         tdata->ciphertext.data,
5085                         tdata->ciphertext.len >> 3,
5086                         "KASUMI Ciphertext data not as expected");
5087
5088                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5089                         ut_params->digest,
5090                         tdata->digest.data,
5091                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5092                         "KASUMI Generated auth tag not as expected");
5093         }
5094         return 0;
5095 }
5096
5097 static int
5098 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5099         uint8_t op_mode, uint8_t verify)
5100 {
5101         struct crypto_testsuite_params *ts_params = &testsuite_params;
5102         struct crypto_unittest_params *ut_params = &unittest_params;
5103
5104         int retval;
5105
5106         const uint8_t *plaintext = NULL;
5107         const uint8_t *ciphertext = NULL;
5108         const uint8_t *digest = NULL;
5109         unsigned int plaintext_pad_len;
5110         unsigned int plaintext_len;
5111         unsigned int ciphertext_pad_len;
5112         unsigned int ciphertext_len;
5113         uint8_t buffer[10000];
5114         uint8_t digest_buffer[10000];
5115
5116         struct rte_cryptodev_info dev_info;
5117
5118         /* Verify the capabilities */
5119         struct rte_cryptodev_sym_capability_idx cap_idx;
5120         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5121         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5122         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5123                         &cap_idx) == NULL)
5124                 return -ENOTSUP;
5125         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5126         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5127         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5128                         &cap_idx) == NULL)
5129                 return -ENOTSUP;
5130
5131         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5132                 return -ENOTSUP;
5133
5134         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5135
5136         uint64_t feat_flags = dev_info.feature_flags;
5137
5138         if (op_mode == IN_PLACE) {
5139                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5140                         printf("Device doesn't support in-place scatter-gather "
5141                                         "in both input and output mbufs.\n");
5142                         return -ENOTSUP;
5143                 }
5144                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5145                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5146                         printf("Device doesn't support RAW data-path APIs.\n");
5147                         return -ENOTSUP;
5148                 }
5149         } else {
5150                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5151                         return -ENOTSUP;
5152                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5153                         printf("Device doesn't support out-of-place scatter-gather "
5154                                         "in both input and output mbufs.\n");
5155                         return -ENOTSUP;
5156                 }
5157                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5158                         printf("Device doesn't support digest encrypted.\n");
5159                         return -ENOTSUP;
5160                 }
5161         }
5162
5163         /* Create KASUMI session */
5164         retval = create_wireless_algo_auth_cipher_session(
5165                         ts_params->valid_devs[0],
5166                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5167                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5168                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5169                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5170                         RTE_CRYPTO_AUTH_KASUMI_F9,
5171                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5172                         tdata->key.data, tdata->key.len,
5173                         0, tdata->digest.len,
5174                         tdata->cipher_iv.len);
5175
5176         if (retval < 0)
5177                 return retval;
5178
5179         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5180         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5181         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5182         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5183
5184         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5185                         plaintext_pad_len, 15, 0);
5186         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5187                         "Failed to allocate input buffer in mempool");
5188
5189         if (op_mode == OUT_OF_PLACE) {
5190                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5191                                 plaintext_pad_len, 15, 0);
5192                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5193                                 "Failed to allocate output buffer in mempool");
5194         }
5195
5196         if (verify) {
5197                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5198                         tdata->ciphertext.data);
5199                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5200                                         ciphertext_len, buffer);
5201                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5202                         ciphertext_len);
5203         } else {
5204                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5205                         tdata->plaintext.data);
5206                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5207                                         plaintext_len, buffer);
5208                 debug_hexdump(stdout, "plaintext:", plaintext,
5209                         plaintext_len);
5210         }
5211         memset(buffer, 0, sizeof(buffer));
5212
5213         /* Create KASUMI operation */
5214         retval = create_wireless_algo_auth_cipher_operation(
5215                 tdata->digest.data, tdata->digest.len,
5216                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5217                 NULL, 0,
5218                 (tdata->digest.offset_bytes == 0 ?
5219                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5220                         : tdata->digest.offset_bytes),
5221                 tdata->validCipherLenInBits.len,
5222                 tdata->validCipherOffsetInBits.len,
5223                 tdata->validAuthLenInBits.len,
5224                 0,
5225                 op_mode, 1, verify);
5226
5227         if (retval < 0)
5228                 return retval;
5229
5230         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5231                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5232                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5233         else
5234                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5235                         ut_params->op);
5236
5237         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5238
5239         ut_params->obuf = (op_mode == IN_PLACE ?
5240                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5241
5242         if (verify) {
5243                 if (ut_params->obuf)
5244                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5245                                         plaintext_len, buffer);
5246                 else
5247                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5248                                         plaintext_len, buffer);
5249
5250                 debug_hexdump(stdout, "plaintext:", plaintext,
5251                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5252                 debug_hexdump(stdout, "plaintext expected:",
5253                         tdata->plaintext.data,
5254                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5255         } else {
5256                 if (ut_params->obuf)
5257                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5258                                         ciphertext_len, buffer);
5259                 else
5260                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5261                                         ciphertext_len, buffer);
5262
5263                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5264                         ciphertext_len);
5265                 debug_hexdump(stdout, "ciphertext expected:",
5266                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5267
5268                 if (ut_params->obuf)
5269                         digest = rte_pktmbuf_read(ut_params->obuf,
5270                                 (tdata->digest.offset_bytes == 0 ?
5271                                 plaintext_pad_len : tdata->digest.offset_bytes),
5272                                 tdata->digest.len, digest_buffer);
5273                 else
5274                         digest = rte_pktmbuf_read(ut_params->ibuf,
5275                                 (tdata->digest.offset_bytes == 0 ?
5276                                 plaintext_pad_len : tdata->digest.offset_bytes),
5277                                 tdata->digest.len, digest_buffer);
5278
5279                 debug_hexdump(stdout, "digest:", digest,
5280                         tdata->digest.len);
5281                 debug_hexdump(stdout, "digest expected:",
5282                         tdata->digest.data, tdata->digest.len);
5283         }
5284
5285         /* Validate obuf */
5286         if (verify) {
5287                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5288                         plaintext,
5289                         tdata->plaintext.data,
5290                         tdata->plaintext.len >> 3,
5291                         "KASUMI Plaintext data not as expected");
5292         } else {
5293                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5294                         ciphertext,
5295                         tdata->ciphertext.data,
5296                         tdata->validDataLenInBits.len,
5297                         "KASUMI Ciphertext data not as expected");
5298
5299                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5300                         digest,
5301                         tdata->digest.data,
5302                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5303                         "KASUMI Generated auth tag not as expected");
5304         }
5305         return 0;
5306 }
5307
5308 static int
5309 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5310 {
5311         struct crypto_testsuite_params *ts_params = &testsuite_params;
5312         struct crypto_unittest_params *ut_params = &unittest_params;
5313
5314         int retval;
5315
5316         uint8_t *plaintext, *ciphertext;
5317         unsigned plaintext_pad_len;
5318         unsigned plaintext_len;
5319         struct rte_cryptodev_info dev_info;
5320
5321         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5322         uint64_t feat_flags = dev_info.feature_flags;
5323
5324         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5325                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5326                 printf("Device doesn't support RAW data-path APIs.\n");
5327                 return -ENOTSUP;
5328         }
5329
5330         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5331                 return -ENOTSUP;
5332
5333         /* Verify the capabilities */
5334         struct rte_cryptodev_sym_capability_idx cap_idx;
5335         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5336         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5337         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5338                         &cap_idx) == NULL)
5339                 return -ENOTSUP;
5340         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5341         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5342         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5343                         &cap_idx) == NULL)
5344                 return -ENOTSUP;
5345
5346         /* Create KASUMI session */
5347         retval = create_wireless_algo_cipher_auth_session(
5348                         ts_params->valid_devs[0],
5349                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5350                         RTE_CRYPTO_AUTH_OP_GENERATE,
5351                         RTE_CRYPTO_AUTH_KASUMI_F9,
5352                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5353                         tdata->key.data, tdata->key.len,
5354                         0, tdata->digest.len,
5355                         tdata->cipher_iv.len);
5356         if (retval < 0)
5357                 return retval;
5358
5359         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5360
5361         /* clear mbuf payload */
5362         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5363                         rte_pktmbuf_tailroom(ut_params->ibuf));
5364
5365         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5366         /* Append data which is padded to a multiple of */
5367         /* the algorithms block size */
5368         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5369         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5370                                 plaintext_pad_len);
5371         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5372
5373         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5374
5375         /* Create KASUMI operation */
5376         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5377                                 tdata->digest.len, NULL, 0,
5378                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5379                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5380                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5381                                 tdata->validCipherOffsetInBits.len,
5382                                 tdata->validAuthLenInBits.len,
5383                                 0
5384                                 );
5385         if (retval < 0)
5386                 return retval;
5387
5388         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5389                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5390                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5391         else
5392                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5393                         ut_params->op);
5394         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5395
5396         if (ut_params->op->sym->m_dst)
5397                 ut_params->obuf = ut_params->op->sym->m_dst;
5398         else
5399                 ut_params->obuf = ut_params->op->sym->m_src;
5400
5401         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5402                                 tdata->validCipherOffsetInBits.len >> 3);
5403
5404         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5405                         + plaintext_pad_len;
5406
5407         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5408                                 (tdata->validCipherOffsetInBits.len >> 3);
5409         /* Validate obuf */
5410         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5411                 ciphertext,
5412                 reference_ciphertext,
5413                 tdata->validCipherLenInBits.len,
5414                 "KASUMI Ciphertext data not as expected");
5415
5416         /* Validate obuf */
5417         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5418                 ut_params->digest,
5419                 tdata->digest.data,
5420                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5421                 "KASUMI Generated auth tag not as expected");
5422         return 0;
5423 }
5424
5425 static int
5426 test_zuc_encryption(const struct wireless_test_data *tdata)
5427 {
5428         struct crypto_testsuite_params *ts_params = &testsuite_params;
5429         struct crypto_unittest_params *ut_params = &unittest_params;
5430
5431         int retval;
5432         uint8_t *plaintext, *ciphertext;
5433         unsigned plaintext_pad_len;
5434         unsigned plaintext_len;
5435         struct rte_cryptodev_info dev_info;
5436
5437         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438         uint64_t feat_flags = dev_info.feature_flags;
5439
5440         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5441                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5442                 printf("Device doesn't support RAW data-path APIs.\n");
5443                 return -ENOTSUP;
5444         }
5445
5446         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5447                 return -ENOTSUP;
5448
5449         struct rte_cryptodev_sym_capability_idx cap_idx;
5450
5451         /* Check if device supports ZUC EEA3 */
5452         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5453         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5454
5455         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5456                         &cap_idx) == NULL)
5457                 return -ENOTSUP;
5458
5459         /* Create ZUC session */
5460         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5461                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5462                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5463                                         tdata->key.data, tdata->key.len,
5464                                         tdata->cipher_iv.len);
5465         if (retval < 0)
5466                 return retval;
5467
5468         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5469
5470         /* Clear mbuf payload */
5471         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5472                rte_pktmbuf_tailroom(ut_params->ibuf));
5473
5474         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5475         /* Append data which is padded to a multiple */
5476         /* of the algorithms block size */
5477         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5478         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5479                                 plaintext_pad_len);
5480         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5481
5482         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5483
5484         /* Create ZUC operation */
5485         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5486                                         tdata->cipher_iv.len,
5487                                         tdata->plaintext.len,
5488                                         0);
5489         if (retval < 0)
5490                 return retval;
5491
5492         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5493                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5494                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5495         else
5496                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5497                                                 ut_params->op);
5498         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5499
5500         ut_params->obuf = ut_params->op->sym->m_dst;
5501         if (ut_params->obuf)
5502                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5503         else
5504                 ciphertext = plaintext;
5505
5506         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5507
5508         /* Validate obuf */
5509         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5510                 ciphertext,
5511                 tdata->ciphertext.data,
5512                 tdata->validCipherLenInBits.len,
5513                 "ZUC Ciphertext data not as expected");
5514         return 0;
5515 }
5516
5517 static int
5518 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5519 {
5520         struct crypto_testsuite_params *ts_params = &testsuite_params;
5521         struct crypto_unittest_params *ut_params = &unittest_params;
5522
5523         int retval;
5524
5525         unsigned int plaintext_pad_len;
5526         unsigned int plaintext_len;
5527         const uint8_t *ciphertext;
5528         uint8_t ciphertext_buffer[2048];
5529         struct rte_cryptodev_info dev_info;
5530
5531         struct rte_cryptodev_sym_capability_idx cap_idx;
5532
5533         /* Check if device supports ZUC EEA3 */
5534         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5535         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5536
5537         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5538                         &cap_idx) == NULL)
5539                 return -ENOTSUP;
5540
5541         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5542                 return -ENOTSUP;
5543
5544         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5545
5546         uint64_t feat_flags = dev_info.feature_flags;
5547
5548         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5549                 printf("Device doesn't support in-place scatter-gather. "
5550                                 "Test Skipped.\n");
5551                 return -ENOTSUP;
5552         }
5553
5554         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5555                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5556                 printf("Device doesn't support RAW data-path APIs.\n");
5557                 return -ENOTSUP;
5558         }
5559
5560         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5561
5562         /* Append data which is padded to a multiple */
5563         /* of the algorithms block size */
5564         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5565
5566         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5567                         plaintext_pad_len, 10, 0);
5568
5569         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5570                         tdata->plaintext.data);
5571
5572         /* Create ZUC session */
5573         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5574                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5575                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5576                         tdata->key.data, tdata->key.len,
5577                         tdata->cipher_iv.len);
5578         if (retval < 0)
5579                 return retval;
5580
5581         /* Clear mbuf payload */
5582
5583         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5584
5585         /* Create ZUC operation */
5586         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5587                         tdata->cipher_iv.len, tdata->plaintext.len,
5588                         0);
5589         if (retval < 0)
5590                 return retval;
5591
5592         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5593                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5594                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5595         else
5596                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5597                                                 ut_params->op);
5598         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5599
5600         ut_params->obuf = ut_params->op->sym->m_dst;
5601         if (ut_params->obuf)
5602                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5603                         0, plaintext_len, ciphertext_buffer);
5604         else
5605                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5606                         0, plaintext_len, ciphertext_buffer);
5607
5608         /* Validate obuf */
5609         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5610
5611         /* Validate obuf */
5612         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5613                 ciphertext,
5614                 tdata->ciphertext.data,
5615                 tdata->validCipherLenInBits.len,
5616                 "ZUC Ciphertext data not as expected");
5617
5618         return 0;
5619 }
5620
5621 static int
5622 test_zuc_authentication(const struct wireless_test_data *tdata)
5623 {
5624         struct crypto_testsuite_params *ts_params = &testsuite_params;
5625         struct crypto_unittest_params *ut_params = &unittest_params;
5626
5627         int retval;
5628         unsigned plaintext_pad_len;
5629         unsigned plaintext_len;
5630         uint8_t *plaintext;
5631
5632         struct rte_cryptodev_sym_capability_idx cap_idx;
5633         struct rte_cryptodev_info dev_info;
5634
5635         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5636         uint64_t feat_flags = dev_info.feature_flags;
5637
5638         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5639                         (tdata->validAuthLenInBits.len % 8 != 0)) {
5640                 printf("Device doesn't support NON-Byte Aligned Data.\n");
5641                 return -ENOTSUP;
5642         }
5643
5644         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646                 printf("Device doesn't support RAW data-path APIs.\n");
5647                 return -ENOTSUP;
5648         }
5649
5650         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5651                 return -ENOTSUP;
5652
5653         /* Check if device supports ZUC EIA3 */
5654         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5655         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5656
5657         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5658                         &cap_idx) == NULL)
5659                 return -ENOTSUP;
5660
5661         /* Create ZUC session */
5662         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5663                         tdata->key.data, tdata->key.len,
5664                         tdata->auth_iv.len, tdata->digest.len,
5665                         RTE_CRYPTO_AUTH_OP_GENERATE,
5666                         RTE_CRYPTO_AUTH_ZUC_EIA3);
5667         if (retval < 0)
5668                 return retval;
5669
5670         /* alloc mbuf and set payload */
5671         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5672
5673         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5674         rte_pktmbuf_tailroom(ut_params->ibuf));
5675
5676         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5677         /* Append data which is padded to a multiple of */
5678         /* the algorithms block size */
5679         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5680         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5681                                 plaintext_pad_len);
5682         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5683
5684         /* Create ZUC operation */
5685         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5686                         tdata->auth_iv.data, tdata->auth_iv.len,
5687                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5688                         tdata->validAuthLenInBits.len,
5689                         0);
5690         if (retval < 0)
5691                 return retval;
5692
5693         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5694                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5695                                 ut_params->op, 0, 1, 1, 0);
5696         else
5697                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5698                                 ut_params->op);
5699         ut_params->obuf = ut_params->op->sym->m_src;
5700         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5701         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5702                         + plaintext_pad_len;
5703
5704         /* Validate obuf */
5705         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5706         ut_params->digest,
5707         tdata->digest.data,
5708         tdata->digest.len,
5709         "ZUC Generated auth tag not as expected");
5710
5711         return 0;
5712 }
5713
5714 static int
5715 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5716         uint8_t op_mode, uint8_t verify)
5717 {
5718         struct crypto_testsuite_params *ts_params = &testsuite_params;
5719         struct crypto_unittest_params *ut_params = &unittest_params;
5720
5721         int retval;
5722
5723         uint8_t *plaintext = NULL, *ciphertext = NULL;
5724         unsigned int plaintext_pad_len;
5725         unsigned int plaintext_len;
5726         unsigned int ciphertext_pad_len;
5727         unsigned int ciphertext_len;
5728
5729         struct rte_cryptodev_info dev_info;
5730         struct rte_cryptodev_sym_capability_idx cap_idx;
5731
5732         /* Check if device supports ZUC EIA3 */
5733         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5734         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5735
5736         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5737                         &cap_idx) == NULL)
5738                 return -ENOTSUP;
5739
5740         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5741
5742         uint64_t feat_flags = dev_info.feature_flags;
5743
5744         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5745                 printf("Device doesn't support digest encrypted.\n");
5746                 return -ENOTSUP;
5747         }
5748         if (op_mode == IN_PLACE) {
5749                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5750                         printf("Device doesn't support in-place scatter-gather "
5751                                         "in both input and output mbufs.\n");
5752                         return -ENOTSUP;
5753                 }
5754
5755                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5756                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5757                         printf("Device doesn't support RAW data-path APIs.\n");
5758                         return -ENOTSUP;
5759                 }
5760         } else {
5761                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5762                         return -ENOTSUP;
5763                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5764                         printf("Device doesn't support out-of-place scatter-gather "
5765                                         "in both input and output mbufs.\n");
5766                         return -ENOTSUP;
5767                 }
5768         }
5769
5770         /* Create ZUC session */
5771         retval = create_wireless_algo_auth_cipher_session(
5772                         ts_params->valid_devs[0],
5773                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5774                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5775                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5776                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5777                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5778                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5779                         tdata->key.data, tdata->key.len,
5780                         tdata->auth_iv.len, tdata->digest.len,
5781                         tdata->cipher_iv.len);
5782
5783         if (retval < 0)
5784                 return retval;
5785
5786         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5787         if (op_mode == OUT_OF_PLACE)
5788                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5789
5790         /* clear mbuf payload */
5791         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5792                 rte_pktmbuf_tailroom(ut_params->ibuf));
5793         if (op_mode == OUT_OF_PLACE)
5794                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5795                         rte_pktmbuf_tailroom(ut_params->obuf));
5796
5797         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5798         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5799         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5800         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5801
5802         if (verify) {
5803                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5804                                         ciphertext_pad_len);
5805                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5806                 if (op_mode == OUT_OF_PLACE)
5807                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5808                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5809                         ciphertext_len);
5810         } else {
5811                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5812                                         plaintext_pad_len);
5813                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5814                 if (op_mode == OUT_OF_PLACE)
5815                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5816                 debug_hexdump(stdout, "plaintext:", plaintext,
5817                         plaintext_len);
5818         }
5819
5820         /* Create ZUC operation */
5821         retval = create_wireless_algo_auth_cipher_operation(
5822                 tdata->digest.data, tdata->digest.len,
5823                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5824                 tdata->auth_iv.data, tdata->auth_iv.len,
5825                 (tdata->digest.offset_bytes == 0 ?
5826                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5827                         : tdata->digest.offset_bytes),
5828                 tdata->validCipherLenInBits.len,
5829                 tdata->validCipherOffsetInBits.len,
5830                 tdata->validAuthLenInBits.len,
5831                 0,
5832                 op_mode, 0, verify);
5833
5834         if (retval < 0)
5835                 return retval;
5836
5837         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5838                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5839                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5840         else
5841                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5842                         ut_params->op);
5843
5844         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5845
5846         ut_params->obuf = (op_mode == IN_PLACE ?
5847                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5848
5849
5850         if (verify) {
5851                 if (ut_params->obuf)
5852                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5853                                                         uint8_t *);
5854                 else
5855                         plaintext = ciphertext;
5856
5857                 debug_hexdump(stdout, "plaintext:", plaintext,
5858                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5859                 debug_hexdump(stdout, "plaintext expected:",
5860                         tdata->plaintext.data,
5861                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5862         } else {
5863                 if (ut_params->obuf)
5864                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5865                                                         uint8_t *);
5866                 else
5867                         ciphertext = plaintext;
5868
5869                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5870                         ciphertext_len);
5871                 debug_hexdump(stdout, "ciphertext expected:",
5872                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5873
5874                 ut_params->digest = rte_pktmbuf_mtod(
5875                         ut_params->obuf, uint8_t *) +
5876                         (tdata->digest.offset_bytes == 0 ?
5877                         plaintext_pad_len : tdata->digest.offset_bytes);
5878
5879                 debug_hexdump(stdout, "digest:", ut_params->digest,
5880                         tdata->digest.len);
5881                 debug_hexdump(stdout, "digest expected:",
5882                         tdata->digest.data, tdata->digest.len);
5883         }
5884
5885         /* Validate obuf */
5886         if (verify) {
5887                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5888                         plaintext,
5889                         tdata->plaintext.data,
5890                         tdata->plaintext.len >> 3,
5891                         "ZUC Plaintext data not as expected");
5892         } else {
5893                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5894                         ciphertext,
5895                         tdata->ciphertext.data,
5896                         tdata->ciphertext.len >> 3,
5897                         "ZUC Ciphertext data not as expected");
5898
5899                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5900                         ut_params->digest,
5901                         tdata->digest.data,
5902                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5903                         "ZUC Generated auth tag not as expected");
5904         }
5905         return 0;
5906 }
5907
5908 static int
5909 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5910         uint8_t op_mode, uint8_t verify)
5911 {
5912         struct crypto_testsuite_params *ts_params = &testsuite_params;
5913         struct crypto_unittest_params *ut_params = &unittest_params;
5914
5915         int retval;
5916
5917         const uint8_t *plaintext = NULL;
5918         const uint8_t *ciphertext = NULL;
5919         const uint8_t *digest = NULL;
5920         unsigned int plaintext_pad_len;
5921         unsigned int plaintext_len;
5922         unsigned int ciphertext_pad_len;
5923         unsigned int ciphertext_len;
5924         uint8_t buffer[10000];
5925         uint8_t digest_buffer[10000];
5926
5927         struct rte_cryptodev_info dev_info;
5928         struct rte_cryptodev_sym_capability_idx cap_idx;
5929
5930         /* Check if device supports ZUC EIA3 */
5931         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5932         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5933
5934         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5935                         &cap_idx) == NULL)
5936                 return -ENOTSUP;
5937
5938         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5939
5940         uint64_t feat_flags = dev_info.feature_flags;
5941
5942         if (op_mode == IN_PLACE) {
5943                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5944                         printf("Device doesn't support in-place scatter-gather "
5945                                         "in both input and output mbufs.\n");
5946                         return -ENOTSUP;
5947                 }
5948
5949                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5950                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5951                         printf("Device doesn't support RAW data-path APIs.\n");
5952                         return -ENOTSUP;
5953                 }
5954         } else {
5955                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5956                         return -ENOTSUP;
5957                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5958                         printf("Device doesn't support out-of-place scatter-gather "
5959                                         "in both input and output mbufs.\n");
5960                         return -ENOTSUP;
5961                 }
5962                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5963                         printf("Device doesn't support digest encrypted.\n");
5964                         return -ENOTSUP;
5965                 }
5966         }
5967
5968         /* Create ZUC session */
5969         retval = create_wireless_algo_auth_cipher_session(
5970                         ts_params->valid_devs[0],
5971                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5972                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5973                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5974                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5975                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5976                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5977                         tdata->key.data, tdata->key.len,
5978                         tdata->auth_iv.len, tdata->digest.len,
5979                         tdata->cipher_iv.len);
5980
5981         if (retval < 0)
5982                 return retval;
5983
5984         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5985         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5986         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5987         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5988
5989         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5990                         plaintext_pad_len, 15, 0);
5991         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5992                         "Failed to allocate input buffer in mempool");
5993
5994         if (op_mode == OUT_OF_PLACE) {
5995                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5996                                 plaintext_pad_len, 15, 0);
5997                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5998                                 "Failed to allocate output buffer in mempool");
5999         }
6000
6001         if (verify) {
6002                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6003                         tdata->ciphertext.data);
6004                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6005                                         ciphertext_len, buffer);
6006                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6007                         ciphertext_len);
6008         } else {
6009                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6010                         tdata->plaintext.data);
6011                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6012                                         plaintext_len, buffer);
6013                 debug_hexdump(stdout, "plaintext:", plaintext,
6014                         plaintext_len);
6015         }
6016         memset(buffer, 0, sizeof(buffer));
6017
6018         /* Create ZUC operation */
6019         retval = create_wireless_algo_auth_cipher_operation(
6020                 tdata->digest.data, tdata->digest.len,
6021                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6022                 NULL, 0,
6023                 (tdata->digest.offset_bytes == 0 ?
6024                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6025                         : tdata->digest.offset_bytes),
6026                 tdata->validCipherLenInBits.len,
6027                 tdata->validCipherOffsetInBits.len,
6028                 tdata->validAuthLenInBits.len,
6029                 0,
6030                 op_mode, 1, verify);
6031
6032         if (retval < 0)
6033                 return retval;
6034
6035         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6036                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6037                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6038         else
6039                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6040                         ut_params->op);
6041
6042         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6043
6044         ut_params->obuf = (op_mode == IN_PLACE ?
6045                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6046
6047         if (verify) {
6048                 if (ut_params->obuf)
6049                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6050                                         plaintext_len, buffer);
6051                 else
6052                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6053                                         plaintext_len, buffer);
6054
6055                 debug_hexdump(stdout, "plaintext:", plaintext,
6056                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6057                 debug_hexdump(stdout, "plaintext expected:",
6058                         tdata->plaintext.data,
6059                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6060         } else {
6061                 if (ut_params->obuf)
6062                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6063                                         ciphertext_len, buffer);
6064                 else
6065                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6066                                         ciphertext_len, buffer);
6067
6068                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6069                         ciphertext_len);
6070                 debug_hexdump(stdout, "ciphertext expected:",
6071                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6072
6073                 if (ut_params->obuf)
6074                         digest = rte_pktmbuf_read(ut_params->obuf,
6075                                 (tdata->digest.offset_bytes == 0 ?
6076                                 plaintext_pad_len : tdata->digest.offset_bytes),
6077                                 tdata->digest.len, digest_buffer);
6078                 else
6079                         digest = rte_pktmbuf_read(ut_params->ibuf,
6080                                 (tdata->digest.offset_bytes == 0 ?
6081                                 plaintext_pad_len : tdata->digest.offset_bytes),
6082                                 tdata->digest.len, digest_buffer);
6083
6084                 debug_hexdump(stdout, "digest:", digest,
6085                         tdata->digest.len);
6086                 debug_hexdump(stdout, "digest expected:",
6087                         tdata->digest.data, tdata->digest.len);
6088         }
6089
6090         /* Validate obuf */
6091         if (verify) {
6092                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6093                         plaintext,
6094                         tdata->plaintext.data,
6095                         tdata->plaintext.len >> 3,
6096                         "ZUC Plaintext data not as expected");
6097         } else {
6098                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6099                         ciphertext,
6100                         tdata->ciphertext.data,
6101                         tdata->validDataLenInBits.len,
6102                         "ZUC Ciphertext data not as expected");
6103
6104                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6105                         digest,
6106                         tdata->digest.data,
6107                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6108                         "ZUC Generated auth tag not as expected");
6109         }
6110         return 0;
6111 }
6112
6113 static int
6114 test_kasumi_encryption_test_case_1(void)
6115 {
6116         return test_kasumi_encryption(&kasumi_test_case_1);
6117 }
6118
6119 static int
6120 test_kasumi_encryption_test_case_1_sgl(void)
6121 {
6122         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6123 }
6124
6125 static int
6126 test_kasumi_encryption_test_case_1_oop(void)
6127 {
6128         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6129 }
6130
6131 static int
6132 test_kasumi_encryption_test_case_1_oop_sgl(void)
6133 {
6134         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6135 }
6136
6137 static int
6138 test_kasumi_encryption_test_case_2(void)
6139 {
6140         return test_kasumi_encryption(&kasumi_test_case_2);
6141 }
6142
6143 static int
6144 test_kasumi_encryption_test_case_3(void)
6145 {
6146         return test_kasumi_encryption(&kasumi_test_case_3);
6147 }
6148
6149 static int
6150 test_kasumi_encryption_test_case_4(void)
6151 {
6152         return test_kasumi_encryption(&kasumi_test_case_4);
6153 }
6154
6155 static int
6156 test_kasumi_encryption_test_case_5(void)
6157 {
6158         return test_kasumi_encryption(&kasumi_test_case_5);
6159 }
6160
6161 static int
6162 test_kasumi_decryption_test_case_1(void)
6163 {
6164         return test_kasumi_decryption(&kasumi_test_case_1);
6165 }
6166
6167 static int
6168 test_kasumi_decryption_test_case_1_oop(void)
6169 {
6170         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6171 }
6172
6173 static int
6174 test_kasumi_decryption_test_case_2(void)
6175 {
6176         return test_kasumi_decryption(&kasumi_test_case_2);
6177 }
6178
6179 static int
6180 test_kasumi_decryption_test_case_3(void)
6181 {
6182         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6183         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6184                 return -ENOTSUP;
6185         return test_kasumi_decryption(&kasumi_test_case_3);
6186 }
6187
6188 static int
6189 test_kasumi_decryption_test_case_4(void)
6190 {
6191         return test_kasumi_decryption(&kasumi_test_case_4);
6192 }
6193
6194 static int
6195 test_kasumi_decryption_test_case_5(void)
6196 {
6197         return test_kasumi_decryption(&kasumi_test_case_5);
6198 }
6199 static int
6200 test_snow3g_encryption_test_case_1(void)
6201 {
6202         return test_snow3g_encryption(&snow3g_test_case_1);
6203 }
6204
6205 static int
6206 test_snow3g_encryption_test_case_1_oop(void)
6207 {
6208         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6209 }
6210
6211 static int
6212 test_snow3g_encryption_test_case_1_oop_sgl(void)
6213 {
6214         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6215 }
6216
6217
6218 static int
6219 test_snow3g_encryption_test_case_1_offset_oop(void)
6220 {
6221         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6222 }
6223
6224 static int
6225 test_snow3g_encryption_test_case_2(void)
6226 {
6227         return test_snow3g_encryption(&snow3g_test_case_2);
6228 }
6229
6230 static int
6231 test_snow3g_encryption_test_case_3(void)
6232 {
6233         return test_snow3g_encryption(&snow3g_test_case_3);
6234 }
6235
6236 static int
6237 test_snow3g_encryption_test_case_4(void)
6238 {
6239         return test_snow3g_encryption(&snow3g_test_case_4);
6240 }
6241
6242 static int
6243 test_snow3g_encryption_test_case_5(void)
6244 {
6245         return test_snow3g_encryption(&snow3g_test_case_5);
6246 }
6247
6248 static int
6249 test_snow3g_decryption_test_case_1(void)
6250 {
6251         return test_snow3g_decryption(&snow3g_test_case_1);
6252 }
6253
6254 static int
6255 test_snow3g_decryption_test_case_1_oop(void)
6256 {
6257         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6258 }
6259
6260 static int
6261 test_snow3g_decryption_test_case_2(void)
6262 {
6263         return test_snow3g_decryption(&snow3g_test_case_2);
6264 }
6265
6266 static int
6267 test_snow3g_decryption_test_case_3(void)
6268 {
6269         return test_snow3g_decryption(&snow3g_test_case_3);
6270 }
6271
6272 static int
6273 test_snow3g_decryption_test_case_4(void)
6274 {
6275         return test_snow3g_decryption(&snow3g_test_case_4);
6276 }
6277
6278 static int
6279 test_snow3g_decryption_test_case_5(void)
6280 {
6281         return test_snow3g_decryption(&snow3g_test_case_5);
6282 }
6283
6284 /*
6285  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6286  * Pattern digest from snow3g_test_data must be allocated as
6287  * 4 last bytes in plaintext.
6288  */
6289 static void
6290 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6291                 struct snow3g_hash_test_data *output)
6292 {
6293         if ((pattern != NULL) && (output != NULL)) {
6294                 output->key.len = pattern->key.len;
6295
6296                 memcpy(output->key.data,
6297                 pattern->key.data, pattern->key.len);
6298
6299                 output->auth_iv.len = pattern->auth_iv.len;
6300
6301                 memcpy(output->auth_iv.data,
6302                 pattern->auth_iv.data, pattern->auth_iv.len);
6303
6304                 output->plaintext.len = pattern->plaintext.len;
6305
6306                 memcpy(output->plaintext.data,
6307                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6308
6309                 output->digest.len = pattern->digest.len;
6310
6311                 memcpy(output->digest.data,
6312                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6313                 pattern->digest.len);
6314
6315                 output->validAuthLenInBits.len =
6316                 pattern->validAuthLenInBits.len;
6317         }
6318 }
6319
6320 /*
6321  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6322  */
6323 static int
6324 test_snow3g_decryption_with_digest_test_case_1(void)
6325 {
6326         struct snow3g_hash_test_data snow3g_hash_data;
6327
6328         /*
6329          * Function prepare data for hash veryfication test case.
6330          * Digest is allocated in 4 last bytes in plaintext, pattern.
6331          */
6332         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6333
6334         return test_snow3g_decryption(&snow3g_test_case_7) &
6335                         test_snow3g_authentication_verify(&snow3g_hash_data);
6336 }
6337
6338 static int
6339 test_snow3g_cipher_auth_test_case_1(void)
6340 {
6341         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6342 }
6343
6344 static int
6345 test_snow3g_auth_cipher_test_case_1(void)
6346 {
6347         return test_snow3g_auth_cipher(
6348                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6349 }
6350
6351 static int
6352 test_snow3g_auth_cipher_test_case_2(void)
6353 {
6354         return test_snow3g_auth_cipher(
6355                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6356 }
6357
6358 static int
6359 test_snow3g_auth_cipher_test_case_2_oop(void)
6360 {
6361         return test_snow3g_auth_cipher(
6362                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6363 }
6364
6365 static int
6366 test_snow3g_auth_cipher_part_digest_enc(void)
6367 {
6368         return test_snow3g_auth_cipher(
6369                 &snow3g_auth_cipher_partial_digest_encryption,
6370                         IN_PLACE, 0);
6371 }
6372
6373 static int
6374 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6375 {
6376         return test_snow3g_auth_cipher(
6377                 &snow3g_auth_cipher_partial_digest_encryption,
6378                         OUT_OF_PLACE, 0);
6379 }
6380
6381 static int
6382 test_snow3g_auth_cipher_test_case_3_sgl(void)
6383 {
6384         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6385         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6386                 return -ENOTSUP;
6387         return test_snow3g_auth_cipher_sgl(
6388                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6389 }
6390
6391 static int
6392 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6393 {
6394         return test_snow3g_auth_cipher_sgl(
6395                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6396 }
6397
6398 static int
6399 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6400 {
6401         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6402         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6403                 return -ENOTSUP;
6404         return test_snow3g_auth_cipher_sgl(
6405                 &snow3g_auth_cipher_partial_digest_encryption,
6406                         IN_PLACE, 0);
6407 }
6408
6409 static int
6410 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6411 {
6412         return test_snow3g_auth_cipher_sgl(
6413                 &snow3g_auth_cipher_partial_digest_encryption,
6414                         OUT_OF_PLACE, 0);
6415 }
6416
6417 static int
6418 test_snow3g_auth_cipher_verify_test_case_1(void)
6419 {
6420         return test_snow3g_auth_cipher(
6421                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6422 }
6423
6424 static int
6425 test_snow3g_auth_cipher_verify_test_case_2(void)
6426 {
6427         return test_snow3g_auth_cipher(
6428                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6429 }
6430
6431 static int
6432 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6433 {
6434         return test_snow3g_auth_cipher(
6435                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6436 }
6437
6438 static int
6439 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6440 {
6441         return test_snow3g_auth_cipher(
6442                 &snow3g_auth_cipher_partial_digest_encryption,
6443                         IN_PLACE, 1);
6444 }
6445
6446 static int
6447 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6448 {
6449         return test_snow3g_auth_cipher(
6450                 &snow3g_auth_cipher_partial_digest_encryption,
6451                         OUT_OF_PLACE, 1);
6452 }
6453
6454 static int
6455 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6456 {
6457         return test_snow3g_auth_cipher_sgl(
6458                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6459 }
6460
6461 static int
6462 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6463 {
6464         return test_snow3g_auth_cipher_sgl(
6465                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6466 }
6467
6468 static int
6469 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6470 {
6471         return test_snow3g_auth_cipher_sgl(
6472                 &snow3g_auth_cipher_partial_digest_encryption,
6473                         IN_PLACE, 1);
6474 }
6475
6476 static int
6477 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6478 {
6479         return test_snow3g_auth_cipher_sgl(
6480                 &snow3g_auth_cipher_partial_digest_encryption,
6481                         OUT_OF_PLACE, 1);
6482 }
6483
6484 static int
6485 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6486 {
6487         return test_snow3g_auth_cipher(
6488                 &snow3g_test_case_7, IN_PLACE, 0);
6489 }
6490
6491 static int
6492 test_kasumi_auth_cipher_test_case_1(void)
6493 {
6494         return test_kasumi_auth_cipher(
6495                 &kasumi_test_case_3, IN_PLACE, 0);
6496 }
6497
6498 static int
6499 test_kasumi_auth_cipher_test_case_2(void)
6500 {
6501         return test_kasumi_auth_cipher(
6502                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6503 }
6504
6505 static int
6506 test_kasumi_auth_cipher_test_case_2_oop(void)
6507 {
6508         return test_kasumi_auth_cipher(
6509                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6510 }
6511
6512 static int
6513 test_kasumi_auth_cipher_test_case_2_sgl(void)
6514 {
6515         return test_kasumi_auth_cipher_sgl(
6516                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6517 }
6518
6519 static int
6520 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6521 {
6522         return test_kasumi_auth_cipher_sgl(
6523                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6524 }
6525
6526 static int
6527 test_kasumi_auth_cipher_verify_test_case_1(void)
6528 {
6529         return test_kasumi_auth_cipher(
6530                 &kasumi_test_case_3, IN_PLACE, 1);
6531 }
6532
6533 static int
6534 test_kasumi_auth_cipher_verify_test_case_2(void)
6535 {
6536         return test_kasumi_auth_cipher(
6537                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6538 }
6539
6540 static int
6541 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6542 {
6543         return test_kasumi_auth_cipher(
6544                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6545 }
6546
6547 static int
6548 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6549 {
6550         return test_kasumi_auth_cipher_sgl(
6551                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6552 }
6553
6554 static int
6555 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6556 {
6557         return test_kasumi_auth_cipher_sgl(
6558                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6559 }
6560
6561 static int
6562 test_kasumi_cipher_auth_test_case_1(void)
6563 {
6564         return test_kasumi_cipher_auth(&kasumi_test_case_6);
6565 }
6566
6567 static int
6568 test_zuc_encryption_test_case_1(void)
6569 {
6570         return test_zuc_encryption(&zuc_test_case_cipher_193b);
6571 }
6572
6573 static int
6574 test_zuc_encryption_test_case_2(void)
6575 {
6576         return test_zuc_encryption(&zuc_test_case_cipher_800b);
6577 }
6578
6579 static int
6580 test_zuc_encryption_test_case_3(void)
6581 {
6582         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6583 }
6584
6585 static int
6586 test_zuc_encryption_test_case_4(void)
6587 {
6588         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6589 }
6590
6591 static int
6592 test_zuc_encryption_test_case_5(void)
6593 {
6594         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6595 }
6596
6597 static int
6598 test_zuc_encryption_test_case_6_sgl(void)
6599 {
6600         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6601 }
6602
6603 static int
6604 test_zuc_hash_generate_test_case_1(void)
6605 {
6606         return test_zuc_authentication(&zuc_test_case_auth_1b);
6607 }
6608
6609 static int
6610 test_zuc_hash_generate_test_case_2(void)
6611 {
6612         return test_zuc_authentication(&zuc_test_case_auth_90b);
6613 }
6614
6615 static int
6616 test_zuc_hash_generate_test_case_3(void)
6617 {
6618         return test_zuc_authentication(&zuc_test_case_auth_577b);
6619 }
6620
6621 static int
6622 test_zuc_hash_generate_test_case_4(void)
6623 {
6624         return test_zuc_authentication(&zuc_test_case_auth_2079b);
6625 }
6626
6627 static int
6628 test_zuc_hash_generate_test_case_5(void)
6629 {
6630         return test_zuc_authentication(&zuc_test_auth_5670b);
6631 }
6632
6633 static int
6634 test_zuc_hash_generate_test_case_6(void)
6635 {
6636         return test_zuc_authentication(&zuc_test_case_auth_128b);
6637 }
6638
6639 static int
6640 test_zuc_hash_generate_test_case_7(void)
6641 {
6642         return test_zuc_authentication(&zuc_test_case_auth_2080b);
6643 }
6644
6645 static int
6646 test_zuc_hash_generate_test_case_8(void)
6647 {
6648         return test_zuc_authentication(&zuc_test_case_auth_584b);
6649 }
6650
6651 static int
6652 test_zuc_cipher_auth_test_case_1(void)
6653 {
6654         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6655 }
6656
6657 static int
6658 test_zuc_cipher_auth_test_case_2(void)
6659 {
6660         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6661 }
6662
6663 static int
6664 test_zuc_auth_cipher_test_case_1(void)
6665 {
6666         return test_zuc_auth_cipher(
6667                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6668 }
6669
6670 static int
6671 test_zuc_auth_cipher_test_case_1_oop(void)
6672 {
6673         return test_zuc_auth_cipher(
6674                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6675 }
6676
6677 static int
6678 test_zuc_auth_cipher_test_case_1_sgl(void)
6679 {
6680         return test_zuc_auth_cipher_sgl(
6681                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6682 }
6683
6684 static int
6685 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6686 {
6687         return test_zuc_auth_cipher_sgl(
6688                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6689 }
6690
6691 static int
6692 test_zuc_auth_cipher_verify_test_case_1(void)
6693 {
6694         return test_zuc_auth_cipher(
6695                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6696 }
6697
6698 static int
6699 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6700 {
6701         return test_zuc_auth_cipher(
6702                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6703 }
6704
6705 static int
6706 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6707 {
6708         return test_zuc_auth_cipher_sgl(
6709                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6710 }
6711
6712 static int
6713 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6714 {
6715         return test_zuc_auth_cipher_sgl(
6716                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6717 }
6718
6719 static int
6720 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6721 {
6722         uint8_t dev_id = testsuite_params.valid_devs[0];
6723
6724         struct rte_cryptodev_sym_capability_idx cap_idx;
6725
6726         /* Check if device supports particular cipher algorithm */
6727         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6728         cap_idx.algo.cipher = tdata->cipher_algo;
6729         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6730                 return -ENOTSUP;
6731
6732         /* Check if device supports particular hash algorithm */
6733         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6734         cap_idx.algo.auth = tdata->auth_algo;
6735         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6736                 return -ENOTSUP;
6737
6738         return 0;
6739 }
6740
6741 static int
6742 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6743         uint8_t op_mode, uint8_t verify)
6744 {
6745         struct crypto_testsuite_params *ts_params = &testsuite_params;
6746         struct crypto_unittest_params *ut_params = &unittest_params;
6747
6748         int retval;
6749
6750         uint8_t *plaintext = NULL, *ciphertext = NULL;
6751         unsigned int plaintext_pad_len;
6752         unsigned int plaintext_len;
6753         unsigned int ciphertext_pad_len;
6754         unsigned int ciphertext_len;
6755
6756         struct rte_cryptodev_info dev_info;
6757         struct rte_crypto_op *op;
6758
6759         /* Check if device supports particular algorithms separately */
6760         if (test_mixed_check_if_unsupported(tdata))
6761                 return -ENOTSUP;
6762         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6763                 return -ENOTSUP;
6764
6765         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6766
6767         uint64_t feat_flags = dev_info.feature_flags;
6768
6769         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6770                 printf("Device doesn't support digest encrypted.\n");
6771                 return -ENOTSUP;
6772         }
6773
6774         /* Create the session */
6775         if (verify)
6776                 retval = create_wireless_algo_cipher_auth_session(
6777                                 ts_params->valid_devs[0],
6778                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6779                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6780                                 tdata->auth_algo,
6781                                 tdata->cipher_algo,
6782                                 tdata->auth_key.data, tdata->auth_key.len,
6783                                 tdata->auth_iv.len, tdata->digest_enc.len,
6784                                 tdata->cipher_iv.len);
6785         else
6786                 retval = create_wireless_algo_auth_cipher_session(
6787                                 ts_params->valid_devs[0],
6788                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6789                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6790                                 tdata->auth_algo,
6791                                 tdata->cipher_algo,
6792                                 tdata->auth_key.data, tdata->auth_key.len,
6793                                 tdata->auth_iv.len, tdata->digest_enc.len,
6794                                 tdata->cipher_iv.len);
6795         if (retval < 0)
6796                 return retval;
6797
6798         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6799         if (op_mode == OUT_OF_PLACE)
6800                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6801
6802         /* clear mbuf payload */
6803         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6804                 rte_pktmbuf_tailroom(ut_params->ibuf));
6805         if (op_mode == OUT_OF_PLACE) {
6806
6807                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6808                                 rte_pktmbuf_tailroom(ut_params->obuf));
6809         }
6810
6811         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6812         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6813         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6814         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6815
6816         if (verify) {
6817                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6818                                 ciphertext_pad_len);
6819                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6820                 if (op_mode == OUT_OF_PLACE)
6821                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6822                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6823                                 ciphertext_len);
6824         } else {
6825                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6826                                 plaintext_pad_len);
6827                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6828                 if (op_mode == OUT_OF_PLACE)
6829                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6830                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6831         }
6832
6833         /* Create the operation */
6834         retval = create_wireless_algo_auth_cipher_operation(
6835                         tdata->digest_enc.data, tdata->digest_enc.len,
6836                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6837                         tdata->auth_iv.data, tdata->auth_iv.len,
6838                         (tdata->digest_enc.offset == 0 ?
6839                                 plaintext_pad_len
6840                                 : tdata->digest_enc.offset),
6841                         tdata->validCipherLen.len_bits,
6842                         tdata->cipher.offset_bits,
6843                         tdata->validAuthLen.len_bits,
6844                         tdata->auth.offset_bits,
6845                         op_mode, 0, verify);
6846
6847         if (retval < 0)
6848                 return retval;
6849
6850         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
6851
6852         /* Check if the op failed because the device doesn't */
6853         /* support this particular combination of algorithms */
6854         if (op == NULL && ut_params->op->status ==
6855                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6856                 printf("Device doesn't support this mixed combination. "
6857                                 "Test Skipped.\n");
6858                 return -ENOTSUP;
6859         }
6860         ut_params->op = op;
6861
6862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6863
6864         ut_params->obuf = (op_mode == IN_PLACE ?
6865                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6866
6867         if (verify) {
6868                 if (ut_params->obuf)
6869                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6870                                                         uint8_t *);
6871                 else
6872                         plaintext = ciphertext +
6873                                         (tdata->cipher.offset_bits >> 3);
6874
6875                 debug_hexdump(stdout, "plaintext:", plaintext,
6876                                 tdata->plaintext.len_bits >> 3);
6877                 debug_hexdump(stdout, "plaintext expected:",
6878                                 tdata->plaintext.data,
6879                                 tdata->plaintext.len_bits >> 3);
6880         } else {
6881                 if (ut_params->obuf)
6882                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6883                                         uint8_t *);
6884                 else
6885                         ciphertext = plaintext;
6886
6887                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6888                                 ciphertext_len);
6889                 debug_hexdump(stdout, "ciphertext expected:",
6890                                 tdata->ciphertext.data,
6891                                 tdata->ciphertext.len_bits >> 3);
6892
6893                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6894                                 + (tdata->digest_enc.offset == 0 ?
6895                 plaintext_pad_len : tdata->digest_enc.offset);
6896
6897                 debug_hexdump(stdout, "digest:", ut_params->digest,
6898                                 tdata->digest_enc.len);
6899                 debug_hexdump(stdout, "digest expected:",
6900                                 tdata->digest_enc.data,
6901                                 tdata->digest_enc.len);
6902         }
6903
6904         /* Validate obuf */
6905         if (verify) {
6906                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6907                                 plaintext,
6908                                 tdata->plaintext.data,
6909                                 tdata->plaintext.len_bits >> 3,
6910                                 "Plaintext data not as expected");
6911         } else {
6912                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6913                                 ciphertext,
6914                                 tdata->ciphertext.data,
6915                                 tdata->validDataLen.len_bits,
6916                                 "Ciphertext data not as expected");
6917
6918                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6919                                 ut_params->digest,
6920                                 tdata->digest_enc.data,
6921                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6922                                 "Generated auth tag not as expected");
6923         }
6924
6925         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6926                         "crypto op processing failed");
6927
6928         return 0;
6929 }
6930
6931 static int
6932 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6933         uint8_t op_mode, uint8_t verify)
6934 {
6935         struct crypto_testsuite_params *ts_params = &testsuite_params;
6936         struct crypto_unittest_params *ut_params = &unittest_params;
6937
6938         int retval;
6939
6940         const uint8_t *plaintext = NULL;
6941         const uint8_t *ciphertext = NULL;
6942         const uint8_t *digest = NULL;
6943         unsigned int plaintext_pad_len;
6944         unsigned int plaintext_len;
6945         unsigned int ciphertext_pad_len;
6946         unsigned int ciphertext_len;
6947         uint8_t buffer[10000];
6948         uint8_t digest_buffer[10000];
6949
6950         struct rte_cryptodev_info dev_info;
6951         struct rte_crypto_op *op;
6952
6953         /* Check if device supports particular algorithms */
6954         if (test_mixed_check_if_unsupported(tdata))
6955                 return -ENOTSUP;
6956         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6957                 return -ENOTSUP;
6958
6959         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6960
6961         uint64_t feat_flags = dev_info.feature_flags;
6962
6963         if (op_mode == IN_PLACE) {
6964                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6965                         printf("Device doesn't support in-place scatter-gather "
6966                                         "in both input and output mbufs.\n");
6967                         return -ENOTSUP;
6968                 }
6969         } else {
6970                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6971                         printf("Device doesn't support out-of-place scatter-gather "
6972                                         "in both input and output mbufs.\n");
6973                         return -ENOTSUP;
6974                 }
6975                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6976                         printf("Device doesn't support digest encrypted.\n");
6977                         return -ENOTSUP;
6978                 }
6979         }
6980
6981         /* Create the session */
6982         if (verify)
6983                 retval = create_wireless_algo_cipher_auth_session(
6984                                 ts_params->valid_devs[0],
6985                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6986                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6987                                 tdata->auth_algo,
6988                                 tdata->cipher_algo,
6989                                 tdata->auth_key.data, tdata->auth_key.len,
6990                                 tdata->auth_iv.len, tdata->digest_enc.len,
6991                                 tdata->cipher_iv.len);
6992         else
6993                 retval = create_wireless_algo_auth_cipher_session(
6994                                 ts_params->valid_devs[0],
6995                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6996                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6997                                 tdata->auth_algo,
6998                                 tdata->cipher_algo,
6999                                 tdata->auth_key.data, tdata->auth_key.len,
7000                                 tdata->auth_iv.len, tdata->digest_enc.len,
7001                                 tdata->cipher_iv.len);
7002         if (retval < 0)
7003                 return retval;
7004
7005         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7006         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7007         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7008         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7009
7010         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7011                         ciphertext_pad_len, 15, 0);
7012         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7013                         "Failed to allocate input buffer in mempool");
7014
7015         if (op_mode == OUT_OF_PLACE) {
7016                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7017                                 plaintext_pad_len, 15, 0);
7018                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7019                                 "Failed to allocate output buffer in mempool");
7020         }
7021
7022         if (verify) {
7023                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7024                         tdata->ciphertext.data);
7025                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7026                                         ciphertext_len, buffer);
7027                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7028                         ciphertext_len);
7029         } else {
7030                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7031                         tdata->plaintext.data);
7032                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7033                                         plaintext_len, buffer);
7034                 debug_hexdump(stdout, "plaintext:", plaintext,
7035                         plaintext_len);
7036         }
7037         memset(buffer, 0, sizeof(buffer));
7038
7039         /* Create the operation */
7040         retval = create_wireless_algo_auth_cipher_operation(
7041                         tdata->digest_enc.data, tdata->digest_enc.len,
7042                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7043                         tdata->auth_iv.data, tdata->auth_iv.len,
7044                         (tdata->digest_enc.offset == 0 ?
7045                                 plaintext_pad_len
7046                                 : tdata->digest_enc.offset),
7047                         tdata->validCipherLen.len_bits,
7048                         tdata->cipher.offset_bits,
7049                         tdata->validAuthLen.len_bits,
7050                         tdata->auth.offset_bits,
7051                         op_mode, 1, verify);
7052
7053         if (retval < 0)
7054                 return retval;
7055
7056         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7057
7058         /* Check if the op failed because the device doesn't */
7059         /* support this particular combination of algorithms */
7060         if (op == NULL && ut_params->op->status ==
7061                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7062                 printf("Device doesn't support this mixed combination. "
7063                                 "Test Skipped.\n");
7064                 return -ENOTSUP;
7065         }
7066         ut_params->op = op;
7067
7068         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7069
7070         ut_params->obuf = (op_mode == IN_PLACE ?
7071                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7072
7073         if (verify) {
7074                 if (ut_params->obuf)
7075                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7076                                         plaintext_len, buffer);
7077                 else
7078                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7079                                         plaintext_len, buffer);
7080
7081                 debug_hexdump(stdout, "plaintext:", plaintext,
7082                                 (tdata->plaintext.len_bits >> 3) -
7083                                 tdata->digest_enc.len);
7084                 debug_hexdump(stdout, "plaintext expected:",
7085                                 tdata->plaintext.data,
7086                                 (tdata->plaintext.len_bits >> 3) -
7087                                 tdata->digest_enc.len);
7088         } else {
7089                 if (ut_params->obuf)
7090                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7091                                         ciphertext_len, buffer);
7092                 else
7093                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7094                                         ciphertext_len, buffer);
7095
7096                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7097                         ciphertext_len);
7098                 debug_hexdump(stdout, "ciphertext expected:",
7099                         tdata->ciphertext.data,
7100                         tdata->ciphertext.len_bits >> 3);
7101
7102                 if (ut_params->obuf)
7103                         digest = rte_pktmbuf_read(ut_params->obuf,
7104                                         (tdata->digest_enc.offset == 0 ?
7105                                                 plaintext_pad_len :
7106                                                 tdata->digest_enc.offset),
7107                                         tdata->digest_enc.len, digest_buffer);
7108                 else
7109                         digest = rte_pktmbuf_read(ut_params->ibuf,
7110                                         (tdata->digest_enc.offset == 0 ?
7111                                                 plaintext_pad_len :
7112                                                 tdata->digest_enc.offset),
7113                                         tdata->digest_enc.len, digest_buffer);
7114
7115                 debug_hexdump(stdout, "digest:", digest,
7116                                 tdata->digest_enc.len);
7117                 debug_hexdump(stdout, "digest expected:",
7118                                 tdata->digest_enc.data, tdata->digest_enc.len);
7119         }
7120
7121         /* Validate obuf */
7122         if (verify) {
7123                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7124                                 plaintext,
7125                                 tdata->plaintext.data,
7126                                 tdata->plaintext.len_bits >> 3,
7127                                 "Plaintext data not as expected");
7128         } else {
7129                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7130                                 ciphertext,
7131                                 tdata->ciphertext.data,
7132                                 tdata->validDataLen.len_bits,
7133                                 "Ciphertext data not as expected");
7134                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7135                                 digest,
7136                                 tdata->digest_enc.data,
7137                                 tdata->digest_enc.len,
7138                                 "Generated auth tag not as expected");
7139         }
7140
7141         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7142                         "crypto op processing failed");
7143
7144         return 0;
7145 }
7146
7147 /** AUTH AES CMAC + CIPHER AES CTR */
7148
7149 static int
7150 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7151 {
7152         return test_mixed_auth_cipher(
7153                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7154 }
7155
7156 static int
7157 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7158 {
7159         return test_mixed_auth_cipher(
7160                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7161 }
7162
7163 static int
7164 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7165 {
7166         return test_mixed_auth_cipher_sgl(
7167                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7168 }
7169
7170 static int
7171 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7172 {
7173         return test_mixed_auth_cipher_sgl(
7174                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7175 }
7176
7177 static int
7178 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7179 {
7180         return test_mixed_auth_cipher(
7181                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7182 }
7183
7184 static int
7185 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7186 {
7187         return test_mixed_auth_cipher(
7188                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7189 }
7190
7191 static int
7192 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7193 {
7194         return test_mixed_auth_cipher_sgl(
7195                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7196 }
7197
7198 static int
7199 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7200 {
7201         return test_mixed_auth_cipher_sgl(
7202                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7203 }
7204
7205 /** MIXED AUTH + CIPHER */
7206
7207 static int
7208 test_auth_zuc_cipher_snow_test_case_1(void)
7209 {
7210         return test_mixed_auth_cipher(
7211                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7212 }
7213
7214 static int
7215 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7216 {
7217         return test_mixed_auth_cipher(
7218                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7219 }
7220
7221 static int
7222 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7223 {
7224         return test_mixed_auth_cipher(
7225                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7226 }
7227
7228 static int
7229 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7230 {
7231         return test_mixed_auth_cipher(
7232                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7233 }
7234
7235 static int
7236 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7237 {
7238         return test_mixed_auth_cipher(
7239                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7240 }
7241
7242 static int
7243 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7244 {
7245         return test_mixed_auth_cipher(
7246                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7247 }
7248
7249 static int
7250 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7251 {
7252         return test_mixed_auth_cipher(
7253                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7254 }
7255
7256 static int
7257 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7258 {
7259         return test_mixed_auth_cipher(
7260                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7261 }
7262
7263 static int
7264 test_auth_snow_cipher_zuc_test_case_1(void)
7265 {
7266         return test_mixed_auth_cipher(
7267                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7268 }
7269
7270 static int
7271 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7272 {
7273         return test_mixed_auth_cipher(
7274                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7275 }
7276
7277 static int
7278 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7279 {
7280         return test_mixed_auth_cipher(
7281                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7282 }
7283
7284 static int
7285 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7286 {
7287         return test_mixed_auth_cipher(
7288                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7289 }
7290
7291 static int
7292 test_auth_null_cipher_snow_test_case_1(void)
7293 {
7294         return test_mixed_auth_cipher(
7295                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7296 }
7297
7298 static int
7299 test_verify_auth_null_cipher_snow_test_case_1(void)
7300 {
7301         return test_mixed_auth_cipher(
7302                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7303 }
7304
7305 static int
7306 test_auth_null_cipher_zuc_test_case_1(void)
7307 {
7308         return test_mixed_auth_cipher(
7309                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7310 }
7311
7312 static int
7313 test_verify_auth_null_cipher_zuc_test_case_1(void)
7314 {
7315         return test_mixed_auth_cipher(
7316                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7317 }
7318
7319 static int
7320 test_auth_snow_cipher_null_test_case_1(void)
7321 {
7322         return test_mixed_auth_cipher(
7323                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7324 }
7325
7326 static int
7327 test_verify_auth_snow_cipher_null_test_case_1(void)
7328 {
7329         return test_mixed_auth_cipher(
7330                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7331 }
7332
7333 static int
7334 test_auth_zuc_cipher_null_test_case_1(void)
7335 {
7336         return test_mixed_auth_cipher(
7337                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7338 }
7339
7340 static int
7341 test_verify_auth_zuc_cipher_null_test_case_1(void)
7342 {
7343         return test_mixed_auth_cipher(
7344                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7345 }
7346
7347 static int
7348 test_auth_null_cipher_aes_ctr_test_case_1(void)
7349 {
7350         return test_mixed_auth_cipher(
7351                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7352 }
7353
7354 static int
7355 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7356 {
7357         return test_mixed_auth_cipher(
7358                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7359 }
7360
7361 static int
7362 test_auth_aes_cmac_cipher_null_test_case_1(void)
7363 {
7364         return test_mixed_auth_cipher(
7365                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7366 }
7367
7368 static int
7369 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7370 {
7371         return test_mixed_auth_cipher(
7372                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7373 }
7374
7375 /* ***** AEAD algorithm Tests ***** */
7376
7377 static int
7378 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7379                 enum rte_crypto_aead_operation op,
7380                 const uint8_t *key, const uint8_t key_len,
7381                 const uint16_t aad_len, const uint8_t auth_len,
7382                 uint8_t iv_len)
7383 {
7384         uint8_t aead_key[key_len];
7385
7386         struct crypto_testsuite_params *ts_params = &testsuite_params;
7387         struct crypto_unittest_params *ut_params = &unittest_params;
7388
7389         memcpy(aead_key, key, key_len);
7390
7391         /* Setup AEAD Parameters */
7392         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7393         ut_params->aead_xform.next = NULL;
7394         ut_params->aead_xform.aead.algo = algo;
7395         ut_params->aead_xform.aead.op = op;
7396         ut_params->aead_xform.aead.key.data = aead_key;
7397         ut_params->aead_xform.aead.key.length = key_len;
7398         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7399         ut_params->aead_xform.aead.iv.length = iv_len;
7400         ut_params->aead_xform.aead.digest_length = auth_len;
7401         ut_params->aead_xform.aead.aad_length = aad_len;
7402
7403         debug_hexdump(stdout, "key:", key, key_len);
7404
7405         /* Create Crypto session*/
7406         ut_params->sess = rte_cryptodev_sym_session_create(
7407                         ts_params->session_mpool);
7408
7409         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7410                         &ut_params->aead_xform,
7411                         ts_params->session_priv_mpool);
7412
7413         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7414
7415         return 0;
7416 }
7417
7418 static int
7419 create_aead_xform(struct rte_crypto_op *op,
7420                 enum rte_crypto_aead_algorithm algo,
7421                 enum rte_crypto_aead_operation aead_op,
7422                 uint8_t *key, const uint8_t key_len,
7423                 const uint8_t aad_len, const uint8_t auth_len,
7424                 uint8_t iv_len)
7425 {
7426         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7427                         "failed to allocate space for crypto transform");
7428
7429         struct rte_crypto_sym_op *sym_op = op->sym;
7430
7431         /* Setup AEAD Parameters */
7432         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7433         sym_op->xform->next = NULL;
7434         sym_op->xform->aead.algo = algo;
7435         sym_op->xform->aead.op = aead_op;
7436         sym_op->xform->aead.key.data = key;
7437         sym_op->xform->aead.key.length = key_len;
7438         sym_op->xform->aead.iv.offset = IV_OFFSET;
7439         sym_op->xform->aead.iv.length = iv_len;
7440         sym_op->xform->aead.digest_length = auth_len;
7441         sym_op->xform->aead.aad_length = aad_len;
7442
7443         debug_hexdump(stdout, "key:", key, key_len);
7444
7445         return 0;
7446 }
7447
7448 static int
7449 create_aead_operation(enum rte_crypto_aead_operation op,
7450                 const struct aead_test_data *tdata)
7451 {
7452         struct crypto_testsuite_params *ts_params = &testsuite_params;
7453         struct crypto_unittest_params *ut_params = &unittest_params;
7454
7455         uint8_t *plaintext, *ciphertext;
7456         unsigned int aad_pad_len, plaintext_pad_len;
7457
7458         /* Generate Crypto op data structure */
7459         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7460                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7461         TEST_ASSERT_NOT_NULL(ut_params->op,
7462                         "Failed to allocate symmetric crypto operation struct");
7463
7464         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7465
7466         /* Append aad data */
7467         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7468                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7469                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7470                                 aad_pad_len);
7471                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7472                                 "no room to append aad");
7473
7474                 sym_op->aead.aad.phys_addr =
7475                                 rte_pktmbuf_iova(ut_params->ibuf);
7476                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7477                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7478                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7479                         tdata->aad.len);
7480
7481                 /* Append IV at the end of the crypto operation*/
7482                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7483                                 uint8_t *, IV_OFFSET);
7484
7485                 /* Copy IV 1 byte after the IV pointer, according to the API */
7486                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7487                 debug_hexdump(stdout, "iv:", iv_ptr,
7488                         tdata->iv.len);
7489         } else {
7490                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7491                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7492                                 aad_pad_len);
7493                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7494                                 "no room to append aad");
7495
7496                 sym_op->aead.aad.phys_addr =
7497                                 rte_pktmbuf_iova(ut_params->ibuf);
7498                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7499                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7500                         tdata->aad.len);
7501
7502                 /* Append IV at the end of the crypto operation*/
7503                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7504                                 uint8_t *, IV_OFFSET);
7505
7506                 if (tdata->iv.len == 0) {
7507                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7508                         debug_hexdump(stdout, "iv:", iv_ptr,
7509                                 AES_GCM_J0_LENGTH);
7510                 } else {
7511                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7512                         debug_hexdump(stdout, "iv:", iv_ptr,
7513                                 tdata->iv.len);
7514                 }
7515         }
7516
7517         /* Append plaintext/ciphertext */
7518         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7519                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7520                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7521                                 plaintext_pad_len);
7522                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7523
7524                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7525                 debug_hexdump(stdout, "plaintext:", plaintext,
7526                                 tdata->plaintext.len);
7527
7528                 if (ut_params->obuf) {
7529                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7530                                         ut_params->obuf,
7531                                         plaintext_pad_len + aad_pad_len);
7532                         TEST_ASSERT_NOT_NULL(ciphertext,
7533                                         "no room to append ciphertext");
7534
7535                         memset(ciphertext + aad_pad_len, 0,
7536                                         tdata->ciphertext.len);
7537                 }
7538         } else {
7539                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7540                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7541                                 plaintext_pad_len);
7542                 TEST_ASSERT_NOT_NULL(ciphertext,
7543                                 "no room to append ciphertext");
7544
7545                 memcpy(ciphertext, tdata->ciphertext.data,
7546                                 tdata->ciphertext.len);
7547                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7548                                 tdata->ciphertext.len);
7549
7550                 if (ut_params->obuf) {
7551                         plaintext = (uint8_t *)rte_pktmbuf_append(
7552                                         ut_params->obuf,
7553                                         plaintext_pad_len + aad_pad_len);
7554                         TEST_ASSERT_NOT_NULL(plaintext,
7555                                         "no room to append plaintext");
7556
7557                         memset(plaintext + aad_pad_len, 0,
7558                                         tdata->plaintext.len);
7559                 }
7560         }
7561
7562         /* Append digest data */
7563         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7564                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7565                                 ut_params->obuf ? ut_params->obuf :
7566                                                 ut_params->ibuf,
7567                                                 tdata->auth_tag.len);
7568                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7569                                 "no room to append digest");
7570                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7571                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7572                                 ut_params->obuf ? ut_params->obuf :
7573                                                 ut_params->ibuf,
7574                                                 plaintext_pad_len +
7575                                                 aad_pad_len);
7576         } else {
7577                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7578                                 ut_params->ibuf, tdata->auth_tag.len);
7579                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7580                                 "no room to append digest");
7581                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7582                                 ut_params->ibuf,
7583                                 plaintext_pad_len + aad_pad_len);
7584
7585                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7586                         tdata->auth_tag.len);
7587                 debug_hexdump(stdout, "digest:",
7588                         sym_op->aead.digest.data,
7589                         tdata->auth_tag.len);
7590         }
7591
7592         sym_op->aead.data.length = tdata->plaintext.len;
7593         sym_op->aead.data.offset = aad_pad_len;
7594
7595         return 0;
7596 }
7597
7598 static int
7599 test_authenticated_encryption(const struct aead_test_data *tdata)
7600 {
7601         struct crypto_testsuite_params *ts_params = &testsuite_params;
7602         struct crypto_unittest_params *ut_params = &unittest_params;
7603
7604         int retval;
7605         uint8_t *ciphertext, *auth_tag;
7606         uint16_t plaintext_pad_len;
7607         uint32_t i;
7608         struct rte_cryptodev_info dev_info;
7609
7610         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7611         uint64_t feat_flags = dev_info.feature_flags;
7612
7613         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
7614                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
7615                 printf("Device doesn't support RAW data-path APIs.\n");
7616                 return -ENOTSUP;
7617         }
7618
7619         /* Verify the capabilities */
7620         struct rte_cryptodev_sym_capability_idx cap_idx;
7621         const struct rte_cryptodev_symmetric_capability *capability;
7622         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7623         cap_idx.algo.aead = tdata->algo;
7624         capability = rte_cryptodev_sym_capability_get(
7625                         ts_params->valid_devs[0], &cap_idx);
7626         if (capability == NULL)
7627                 return -ENOTSUP;
7628         if (rte_cryptodev_sym_capability_check_aead(
7629                         capability, tdata->key.len, tdata->auth_tag.len,
7630                         tdata->aad.len, tdata->iv.len))
7631                 return -ENOTSUP;
7632
7633         /* Create AEAD session */
7634         retval = create_aead_session(ts_params->valid_devs[0],
7635                         tdata->algo,
7636                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7637                         tdata->key.data, tdata->key.len,
7638                         tdata->aad.len, tdata->auth_tag.len,
7639                         tdata->iv.len);
7640         if (retval < 0)
7641                 return retval;
7642
7643         if (tdata->aad.len > MBUF_SIZE) {
7644                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7645                 /* Populate full size of add data */
7646                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7647                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7648         } else
7649                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7650
7651         /* clear mbuf payload */
7652         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7653                         rte_pktmbuf_tailroom(ut_params->ibuf));
7654
7655         /* Create AEAD operation */
7656         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7657         if (retval < 0)
7658                 return retval;
7659
7660         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7661
7662         ut_params->op->sym->m_src = ut_params->ibuf;
7663
7664         /* Process crypto operation */
7665         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7666                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7667         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7668                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
7669                                 ut_params->op, 0, 0, 0, 0);
7670         else
7671                 TEST_ASSERT_NOT_NULL(
7672                         process_crypto_request(ts_params->valid_devs[0],
7673                         ut_params->op), "failed to process sym crypto op");
7674
7675         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7676                         "crypto op processing failed");
7677
7678         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7679
7680         if (ut_params->op->sym->m_dst) {
7681                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7682                                 uint8_t *);
7683                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7684                                 uint8_t *, plaintext_pad_len);
7685         } else {
7686                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7687                                 uint8_t *,
7688                                 ut_params->op->sym->cipher.data.offset);
7689                 auth_tag = ciphertext + plaintext_pad_len;
7690         }
7691
7692         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7693         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7694
7695         /* Validate obuf */
7696         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7697                         ciphertext,
7698                         tdata->ciphertext.data,
7699                         tdata->ciphertext.len,
7700                         "Ciphertext data not as expected");
7701
7702         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7703                         auth_tag,
7704                         tdata->auth_tag.data,
7705                         tdata->auth_tag.len,
7706                         "Generated auth tag not as expected");
7707
7708         return 0;
7709
7710 }
7711
7712 #ifdef RTE_LIB_SECURITY
7713 static int
7714 security_proto_supported(enum rte_security_session_action_type action,
7715         enum rte_security_session_protocol proto)
7716 {
7717         struct crypto_testsuite_params *ts_params = &testsuite_params;
7718
7719         const struct rte_security_capability *capabilities;
7720         const struct rte_security_capability *capability;
7721         uint16_t i = 0;
7722
7723         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7724                                 rte_cryptodev_get_sec_ctx(
7725                                 ts_params->valid_devs[0]);
7726
7727
7728         capabilities = rte_security_capabilities_get(ctx);
7729
7730         if (capabilities == NULL)
7731                 return -ENOTSUP;
7732
7733         while ((capability = &capabilities[i++])->action !=
7734                         RTE_SECURITY_ACTION_TYPE_NONE) {
7735                 if (capability->action == action &&
7736                                 capability->protocol == proto)
7737                         return 0;
7738         }
7739
7740         return -ENOTSUP;
7741 }
7742
7743 /* Basic algorithm run function for async inplace mode.
7744  * Creates a session from input parameters and runs one operation
7745  * on input_vec. Checks the output of the crypto operation against
7746  * output_vec.
7747  */
7748 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
7749                            enum rte_crypto_auth_operation opa,
7750                            const uint8_t *input_vec, unsigned int input_vec_len,
7751                            const uint8_t *output_vec,
7752                            unsigned int output_vec_len,
7753                            enum rte_crypto_cipher_algorithm cipher_alg,
7754                            const uint8_t *cipher_key, uint32_t cipher_key_len,
7755                            enum rte_crypto_auth_algorithm auth_alg,
7756                            const uint8_t *auth_key, uint32_t auth_key_len,
7757                            uint8_t bearer, enum rte_security_pdcp_domain domain,
7758                            uint8_t packet_direction, uint8_t sn_size,
7759                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
7760 {
7761         struct crypto_testsuite_params *ts_params = &testsuite_params;
7762         struct crypto_unittest_params *ut_params = &unittest_params;
7763         uint8_t *plaintext;
7764         int ret = TEST_SUCCESS;
7765         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7766                                 rte_cryptodev_get_sec_ctx(
7767                                 ts_params->valid_devs[0]);
7768
7769         /* Verify the capabilities */
7770         struct rte_security_capability_idx sec_cap_idx;
7771
7772         sec_cap_idx.action = ut_params->type;
7773         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7774         sec_cap_idx.pdcp.domain = domain;
7775         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7776                 return -ENOTSUP;
7777
7778         /* Generate test mbuf data */
7779         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7780
7781         /* clear mbuf payload */
7782         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7783                         rte_pktmbuf_tailroom(ut_params->ibuf));
7784
7785         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7786                                                   input_vec_len);
7787         memcpy(plaintext, input_vec, input_vec_len);
7788
7789         /* Out of place support */
7790         if (oop) {
7791                 /*
7792                  * For out-op-place we need to alloc another mbuf
7793                  */
7794                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7795                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7796         }
7797
7798         /* Setup Cipher Parameters */
7799         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7800         ut_params->cipher_xform.cipher.algo = cipher_alg;
7801         ut_params->cipher_xform.cipher.op = opc;
7802         ut_params->cipher_xform.cipher.key.data = cipher_key;
7803         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
7804         ut_params->cipher_xform.cipher.iv.length =
7805                                 packet_direction ? 4 : 0;
7806         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7807
7808         /* Setup HMAC Parameters if ICV header is required */
7809         if (auth_alg != 0) {
7810                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7811                 ut_params->auth_xform.next = NULL;
7812                 ut_params->auth_xform.auth.algo = auth_alg;
7813                 ut_params->auth_xform.auth.op = opa;
7814                 ut_params->auth_xform.auth.key.data = auth_key;
7815                 ut_params->auth_xform.auth.key.length = auth_key_len;
7816
7817                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7818         } else {
7819                 ut_params->cipher_xform.next = NULL;
7820         }
7821
7822         struct rte_security_session_conf sess_conf = {
7823                 .action_type = ut_params->type,
7824                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7825                 {.pdcp = {
7826                         .bearer = bearer,
7827                         .domain = domain,
7828                         .pkt_dir = packet_direction,
7829                         .sn_size = sn_size,
7830                         .hfn = packet_direction ? 0 : hfn,
7831                         /**
7832                          * hfn can be set as pdcp_test_hfn[i]
7833                          * if hfn_ovrd is not set. Here, PDCP
7834                          * packet direction is just used to
7835                          * run half of the cases with session
7836                          * HFN and other half with per packet
7837                          * HFN.
7838                          */
7839                         .hfn_threshold = hfn_threshold,
7840                         .hfn_ovrd = packet_direction ? 1 : 0,
7841                         .sdap_enabled = sdap,
7842                 } },
7843                 .crypto_xform = &ut_params->cipher_xform
7844         };
7845
7846         /* Create security session */
7847         ut_params->sec_session = rte_security_session_create(ctx,
7848                                 &sess_conf, ts_params->session_mpool,
7849                                 ts_params->session_priv_mpool);
7850
7851         if (!ut_params->sec_session) {
7852                 printf("TestCase %s()-%d line %d failed %s: ",
7853                         __func__, i, __LINE__, "Failed to allocate session");
7854                 ret = TEST_FAILED;
7855                 goto on_err;
7856         }
7857
7858         /* Generate crypto op data structure */
7859         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7860                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7861         if (!ut_params->op) {
7862                 printf("TestCase %s()-%d line %d failed %s: ",
7863                         __func__, i, __LINE__,
7864                         "Failed to allocate symmetric crypto operation struct");
7865                 ret = TEST_FAILED;
7866                 goto on_err;
7867         }
7868
7869         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
7870                                         uint32_t *, IV_OFFSET);
7871         *per_pkt_hfn = packet_direction ? hfn : 0;
7872
7873         rte_security_attach_session(ut_params->op, ut_params->sec_session);
7874
7875         /* set crypto operation source mbuf */
7876         ut_params->op->sym->m_src = ut_params->ibuf;
7877         if (oop)
7878                 ut_params->op->sym->m_dst = ut_params->obuf;
7879
7880         /* Process crypto operation */
7881         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7882                 == NULL) {
7883                 printf("TestCase %s()-%d line %d failed %s: ",
7884                         __func__, i, __LINE__,
7885                         "failed to process sym crypto op");
7886                 ret = TEST_FAILED;
7887                 goto on_err;
7888         }
7889
7890         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7891                 printf("TestCase %s()-%d line %d failed %s: ",
7892                         __func__, i, __LINE__, "crypto op processing failed");
7893                 ret = TEST_FAILED;
7894                 goto on_err;
7895         }
7896
7897         /* Validate obuf */
7898         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7899                         uint8_t *);
7900         if (oop) {
7901                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7902                                 uint8_t *);
7903         }
7904
7905         if (memcmp(ciphertext, output_vec, output_vec_len)) {
7906                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7907                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7908                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7909                 ret = TEST_FAILED;
7910                 goto on_err;
7911         }
7912
7913 on_err:
7914         rte_crypto_op_free(ut_params->op);
7915         ut_params->op = NULL;
7916
7917         if (ut_params->sec_session)
7918                 rte_security_session_destroy(ctx, ut_params->sec_session);
7919         ut_params->sec_session = NULL;
7920
7921         rte_pktmbuf_free(ut_params->ibuf);
7922         ut_params->ibuf = NULL;
7923         if (oop) {
7924                 rte_pktmbuf_free(ut_params->obuf);
7925                 ut_params->obuf = NULL;
7926         }
7927
7928         return ret;
7929 }
7930
7931 static int
7932 test_pdcp_proto_SGL(int i, int oop,
7933         enum rte_crypto_cipher_operation opc,
7934         enum rte_crypto_auth_operation opa,
7935         uint8_t *input_vec,
7936         unsigned int input_vec_len,
7937         uint8_t *output_vec,
7938         unsigned int output_vec_len,
7939         uint32_t fragsz,
7940         uint32_t fragsz_oop)
7941 {
7942         struct crypto_testsuite_params *ts_params = &testsuite_params;
7943         struct crypto_unittest_params *ut_params = &unittest_params;
7944         uint8_t *plaintext;
7945         struct rte_mbuf *buf, *buf_oop = NULL;
7946         int ret = TEST_SUCCESS;
7947         int to_trn = 0;
7948         int to_trn_tbl[16];
7949         int segs = 1;
7950         unsigned int trn_data = 0;
7951         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7952                                 rte_cryptodev_get_sec_ctx(
7953                                 ts_params->valid_devs[0]);
7954
7955         /* Verify the capabilities */
7956         struct rte_security_capability_idx sec_cap_idx;
7957
7958         sec_cap_idx.action = ut_params->type;
7959         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7960         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7961         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7962                 return -ENOTSUP;
7963
7964         if (fragsz > input_vec_len)
7965                 fragsz = input_vec_len;
7966
7967         uint16_t plaintext_len = fragsz;
7968         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7969
7970         if (fragsz_oop > output_vec_len)
7971                 frag_size_oop = output_vec_len;
7972
7973         int ecx = 0;
7974         if (input_vec_len % fragsz != 0) {
7975                 if (input_vec_len / fragsz + 1 > 16)
7976                         return 1;
7977         } else if (input_vec_len / fragsz > 16)
7978                 return 1;
7979
7980         /* Out of place support */
7981         if (oop) {
7982                 /*
7983                  * For out-op-place we need to alloc another mbuf
7984                  */
7985                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7986                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7987                 buf_oop = ut_params->obuf;
7988         }
7989
7990         /* Generate test mbuf data */
7991         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7992
7993         /* clear mbuf payload */
7994         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7995                         rte_pktmbuf_tailroom(ut_params->ibuf));
7996
7997         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7998                                                   plaintext_len);
7999         memcpy(plaintext, input_vec, plaintext_len);
8000         trn_data += plaintext_len;
8001
8002         buf = ut_params->ibuf;
8003
8004         /*
8005          * Loop until no more fragments
8006          */
8007
8008         while (trn_data < input_vec_len) {
8009                 ++segs;
8010                 to_trn = (input_vec_len - trn_data < fragsz) ?
8011                                 (input_vec_len - trn_data) : fragsz;
8012
8013                 to_trn_tbl[ecx++] = to_trn;
8014
8015                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8016                 buf = buf->next;
8017
8018                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8019                                 rte_pktmbuf_tailroom(buf));
8020
8021                 /* OOP */
8022                 if (oop && !fragsz_oop) {
8023                         buf_oop->next =
8024                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8025                         buf_oop = buf_oop->next;
8026                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8027                                         0, rte_pktmbuf_tailroom(buf_oop));
8028                         rte_pktmbuf_append(buf_oop, to_trn);
8029                 }
8030
8031                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8032                                 to_trn);
8033
8034                 memcpy(plaintext, input_vec + trn_data, to_trn);
8035                 trn_data += to_trn;
8036         }
8037
8038         ut_params->ibuf->nb_segs = segs;
8039
8040         segs = 1;
8041         if (fragsz_oop && oop) {
8042                 to_trn = 0;
8043                 ecx = 0;
8044
8045                 trn_data = frag_size_oop;
8046                 while (trn_data < output_vec_len) {
8047                         ++segs;
8048                         to_trn =
8049                                 (output_vec_len - trn_data <
8050                                                 frag_size_oop) ?
8051                                 (output_vec_len - trn_data) :
8052                                                 frag_size_oop;
8053
8054                         to_trn_tbl[ecx++] = to_trn;
8055
8056                         buf_oop->next =
8057                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8058                         buf_oop = buf_oop->next;
8059                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8060                                         0, rte_pktmbuf_tailroom(buf_oop));
8061                         rte_pktmbuf_append(buf_oop, to_trn);
8062
8063                         trn_data += to_trn;
8064                 }
8065                 ut_params->obuf->nb_segs = segs;
8066         }
8067
8068         /* Setup Cipher Parameters */
8069         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8070         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8071         ut_params->cipher_xform.cipher.op = opc;
8072         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8073         ut_params->cipher_xform.cipher.key.length =
8074                                         pdcp_test_params[i].cipher_key_len;
8075         ut_params->cipher_xform.cipher.iv.length = 0;
8076
8077         /* Setup HMAC Parameters if ICV header is required */
8078         if (pdcp_test_params[i].auth_alg != 0) {
8079                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8080                 ut_params->auth_xform.next = NULL;
8081                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8082                 ut_params->auth_xform.auth.op = opa;
8083                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8084                 ut_params->auth_xform.auth.key.length =
8085                                         pdcp_test_params[i].auth_key_len;
8086
8087                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8088         } else {
8089                 ut_params->cipher_xform.next = NULL;
8090         }
8091
8092         struct rte_security_session_conf sess_conf = {
8093                 .action_type = ut_params->type,
8094                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8095                 {.pdcp = {
8096                         .bearer = pdcp_test_bearer[i],
8097                         .domain = pdcp_test_params[i].domain,
8098                         .pkt_dir = pdcp_test_packet_direction[i],
8099                         .sn_size = pdcp_test_data_sn_size[i],
8100                         .hfn = pdcp_test_hfn[i],
8101                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8102                         .hfn_ovrd = 0,
8103                 } },
8104                 .crypto_xform = &ut_params->cipher_xform
8105         };
8106
8107         /* Create security session */
8108         ut_params->sec_session = rte_security_session_create(ctx,
8109                                 &sess_conf, ts_params->session_mpool,
8110                                 ts_params->session_priv_mpool);
8111
8112         if (!ut_params->sec_session) {
8113                 printf("TestCase %s()-%d line %d failed %s: ",
8114                         __func__, i, __LINE__, "Failed to allocate session");
8115                 ret = TEST_FAILED;
8116                 goto on_err;
8117         }
8118
8119         /* Generate crypto op data structure */
8120         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8121                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8122         if (!ut_params->op) {
8123                 printf("TestCase %s()-%d line %d failed %s: ",
8124                         __func__, i, __LINE__,
8125                         "Failed to allocate symmetric crypto operation struct");
8126                 ret = TEST_FAILED;
8127                 goto on_err;
8128         }
8129
8130         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8131
8132         /* set crypto operation source mbuf */
8133         ut_params->op->sym->m_src = ut_params->ibuf;
8134         if (oop)
8135                 ut_params->op->sym->m_dst = ut_params->obuf;
8136
8137         /* Process crypto operation */
8138         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8139                 == NULL) {
8140                 printf("TestCase %s()-%d line %d failed %s: ",
8141                         __func__, i, __LINE__,
8142                         "failed to process sym crypto op");
8143                 ret = TEST_FAILED;
8144                 goto on_err;
8145         }
8146
8147         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8148                 printf("TestCase %s()-%d line %d failed %s: ",
8149                         __func__, i, __LINE__, "crypto op processing failed");
8150                 ret = TEST_FAILED;
8151                 goto on_err;
8152         }
8153
8154         /* Validate obuf */
8155         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8156                         uint8_t *);
8157         if (oop) {
8158                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8159                                 uint8_t *);
8160         }
8161         if (fragsz_oop)
8162                 fragsz = frag_size_oop;
8163         if (memcmp(ciphertext, output_vec, fragsz)) {
8164                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8165                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8166                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8167                 ret = TEST_FAILED;
8168                 goto on_err;
8169         }
8170
8171         buf = ut_params->op->sym->m_src->next;
8172         if (oop)
8173                 buf = ut_params->op->sym->m_dst->next;
8174
8175         unsigned int off = fragsz;
8176
8177         ecx = 0;
8178         while (buf) {
8179                 ciphertext = rte_pktmbuf_mtod(buf,
8180                                 uint8_t *);
8181                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8182                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8183                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8184                         rte_hexdump(stdout, "reference", output_vec + off,
8185                                         to_trn_tbl[ecx]);
8186                         ret = TEST_FAILED;
8187                         goto on_err;
8188                 }
8189                 off += to_trn_tbl[ecx++];
8190                 buf = buf->next;
8191         }
8192 on_err:
8193         rte_crypto_op_free(ut_params->op);
8194         ut_params->op = NULL;
8195
8196         if (ut_params->sec_session)
8197                 rte_security_session_destroy(ctx, ut_params->sec_session);
8198         ut_params->sec_session = NULL;
8199
8200         rte_pktmbuf_free(ut_params->ibuf);
8201         ut_params->ibuf = NULL;
8202         if (oop) {
8203                 rte_pktmbuf_free(ut_params->obuf);
8204                 ut_params->obuf = NULL;
8205         }
8206
8207         return ret;
8208 }
8209
8210 int
8211 test_pdcp_proto_cplane_encap(int i)
8212 {
8213         return test_pdcp_proto(
8214                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8215                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8216                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8217                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8218                 pdcp_test_params[i].cipher_key_len,
8219                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8220                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8221                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8222                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8223                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8224 }
8225
8226 int
8227 test_pdcp_proto_uplane_encap(int i)
8228 {
8229         return test_pdcp_proto(
8230                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8231                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8232                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8233                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8234                 pdcp_test_params[i].cipher_key_len,
8235                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8236                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8237                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8238                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8239                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8240 }
8241
8242 int
8243 test_pdcp_proto_uplane_encap_with_int(int i)
8244 {
8245         return test_pdcp_proto(
8246                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8247                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8248                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8249                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8250                 pdcp_test_params[i].cipher_key_len,
8251                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8252                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8253                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8254                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8255                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8256 }
8257
8258 int
8259 test_pdcp_proto_cplane_decap(int i)
8260 {
8261         return test_pdcp_proto(
8262                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8263                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8264                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8265                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8266                 pdcp_test_params[i].cipher_key_len,
8267                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8268                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8269                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8270                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8271                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8272 }
8273
8274 int
8275 test_pdcp_proto_uplane_decap(int i)
8276 {
8277         return test_pdcp_proto(
8278                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8279                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8280                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8281                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8282                 pdcp_test_params[i].cipher_key_len,
8283                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8284                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8285                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8286                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8287                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8288 }
8289
8290 int
8291 test_pdcp_proto_uplane_decap_with_int(int i)
8292 {
8293         return test_pdcp_proto(
8294                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8295                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8296                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8297                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8298                 pdcp_test_params[i].cipher_key_len,
8299                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8300                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8301                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8302                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8303                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8304 }
8305
8306 static int
8307 test_PDCP_PROTO_SGL_in_place_32B(void)
8308 {
8309         /* i can be used for running any PDCP case
8310          * In this case it is uplane 12-bit AES-SNOW DL encap
8311          */
8312         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8313         return test_pdcp_proto_SGL(i, IN_PLACE,
8314                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8315                         RTE_CRYPTO_AUTH_OP_GENERATE,
8316                         pdcp_test_data_in[i],
8317                         pdcp_test_data_in_len[i],
8318                         pdcp_test_data_out[i],
8319                         pdcp_test_data_in_len[i]+4,
8320                         32, 0);
8321 }
8322 static int
8323 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8324 {
8325         /* i can be used for running any PDCP case
8326          * In this case it is uplane 18-bit NULL-NULL DL encap
8327          */
8328         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8329         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8330                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8331                         RTE_CRYPTO_AUTH_OP_GENERATE,
8332                         pdcp_test_data_in[i],
8333                         pdcp_test_data_in_len[i],
8334                         pdcp_test_data_out[i],
8335                         pdcp_test_data_in_len[i]+4,
8336                         32, 128);
8337 }
8338 static int
8339 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8340 {
8341         /* i can be used for running any PDCP case
8342          * In this case it is uplane 18-bit AES DL encap
8343          */
8344         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8345                         + DOWNLINK;
8346         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8347                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8348                         RTE_CRYPTO_AUTH_OP_GENERATE,
8349                         pdcp_test_data_in[i],
8350                         pdcp_test_data_in_len[i],
8351                         pdcp_test_data_out[i],
8352                         pdcp_test_data_in_len[i],
8353                         32, 40);
8354 }
8355 static int
8356 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8357 {
8358         /* i can be used for running any PDCP case
8359          * In this case it is cplane 12-bit AES-ZUC DL encap
8360          */
8361         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8362         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8363                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8364                         RTE_CRYPTO_AUTH_OP_GENERATE,
8365                         pdcp_test_data_in[i],
8366                         pdcp_test_data_in_len[i],
8367                         pdcp_test_data_out[i],
8368                         pdcp_test_data_in_len[i]+4,
8369                         128, 32);
8370 }
8371
8372 static int
8373 test_PDCP_SDAP_PROTO_encap_all(void)
8374 {
8375         int i = 0, size = 0;
8376         int err, all_err = TEST_SUCCESS;
8377         const struct pdcp_sdap_test *cur_test;
8378
8379         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8380
8381         for (i = 0; i < size; i++) {
8382                 cur_test = &list_pdcp_sdap_tests[i];
8383                 err = test_pdcp_proto(
8384                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8385                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8386                         cur_test->in_len, cur_test->data_out,
8387                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8388                         cur_test->param.cipher_alg, cur_test->cipher_key,
8389                         cur_test->param.cipher_key_len,
8390                         cur_test->param.auth_alg,
8391                         cur_test->auth_key, cur_test->param.auth_key_len,
8392                         cur_test->bearer, cur_test->param.domain,
8393                         cur_test->packet_direction, cur_test->sn_size,
8394                         cur_test->hfn,
8395                         cur_test->hfn_threshold, SDAP_ENABLED);
8396                 if (err) {
8397                         printf("\t%d) %s: Encapsulation failed\n",
8398                                         cur_test->test_idx,
8399                                         cur_test->param.name);
8400                         err = TEST_FAILED;
8401                 } else {
8402                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8403                                         cur_test->param.name);
8404                         err = TEST_SUCCESS;
8405                 }
8406                 all_err += err;
8407         }
8408
8409         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8410
8411         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8412 }
8413
8414 static int
8415 test_PDCP_SDAP_PROTO_decap_all(void)
8416 {
8417         int i = 0, size = 0;
8418         int err, all_err = TEST_SUCCESS;
8419         const struct pdcp_sdap_test *cur_test;
8420
8421         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8422
8423         for (i = 0; i < size; i++) {
8424                 cur_test = &list_pdcp_sdap_tests[i];
8425                 err = test_pdcp_proto(
8426                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8427                         RTE_CRYPTO_AUTH_OP_VERIFY,
8428                         cur_test->data_out,
8429                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8430                         cur_test->data_in, cur_test->in_len,
8431                         cur_test->param.cipher_alg,
8432                         cur_test->cipher_key, cur_test->param.cipher_key_len,
8433                         cur_test->param.auth_alg, cur_test->auth_key,
8434                         cur_test->param.auth_key_len, cur_test->bearer,
8435                         cur_test->param.domain, cur_test->packet_direction,
8436                         cur_test->sn_size, cur_test->hfn,
8437                         cur_test->hfn_threshold, SDAP_ENABLED);
8438                 if (err) {
8439                         printf("\t%d) %s: Decapsulation failed\n",
8440                                         cur_test->test_idx,
8441                                         cur_test->param.name);
8442                         err = TEST_FAILED;
8443                 } else {
8444                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8445                                         cur_test->param.name);
8446                         err = TEST_SUCCESS;
8447                 }
8448                 all_err += err;
8449         }
8450
8451         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8452
8453         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8454 }
8455
8456 static int
8457 test_PDCP_PROTO_all(void)
8458 {
8459         struct crypto_testsuite_params *ts_params = &testsuite_params;
8460         struct crypto_unittest_params *ut_params = &unittest_params;
8461         struct rte_cryptodev_info dev_info;
8462         int status;
8463
8464         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8465         uint64_t feat_flags = dev_info.feature_flags;
8466
8467         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8468                 return -ENOTSUP;
8469
8470         /* Set action type */
8471         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8472                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8473                 gbl_action_type;
8474
8475         if (security_proto_supported(ut_params->type,
8476                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
8477                 return -ENOTSUP;
8478
8479         status = test_PDCP_PROTO_cplane_encap_all();
8480         status += test_PDCP_PROTO_cplane_decap_all();
8481         status += test_PDCP_PROTO_uplane_encap_all();
8482         status += test_PDCP_PROTO_uplane_decap_all();
8483         status += test_PDCP_PROTO_SGL_in_place_32B();
8484         status += test_PDCP_PROTO_SGL_oop_32B_128B();
8485         status += test_PDCP_PROTO_SGL_oop_32B_40B();
8486         status += test_PDCP_PROTO_SGL_oop_128B_32B();
8487         status += test_PDCP_SDAP_PROTO_encap_all();
8488         status += test_PDCP_SDAP_PROTO_decap_all();
8489
8490         if (status)
8491                 return TEST_FAILED;
8492         else
8493                 return TEST_SUCCESS;
8494 }
8495
8496 static int
8497 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
8498 {
8499         struct crypto_testsuite_params *ts_params = &testsuite_params;
8500         struct crypto_unittest_params *ut_params = &unittest_params;
8501         uint8_t *plaintext, *ciphertext;
8502         uint8_t *iv_ptr;
8503         int32_t cipher_len, crc_len;
8504         uint32_t crc_data_len;
8505         int ret = TEST_SUCCESS;
8506
8507         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8508                                         rte_cryptodev_get_sec_ctx(
8509                                                 ts_params->valid_devs[0]);
8510
8511         /* Verify the capabilities */
8512         struct rte_security_capability_idx sec_cap_idx;
8513         const struct rte_security_capability *sec_cap;
8514         const struct rte_cryptodev_capabilities *crypto_cap;
8515         const struct rte_cryptodev_symmetric_capability *sym_cap;
8516         int j = 0;
8517
8518         sec_cap_idx.action = ut_params->type;
8519         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8520         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
8521
8522         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8523         if (sec_cap == NULL)
8524                 return -ENOTSUP;
8525
8526         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8527                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8528                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8529                                 crypto_cap->sym.xform_type ==
8530                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8531                                 crypto_cap->sym.cipher.algo ==
8532                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8533                         sym_cap = &crypto_cap->sym;
8534                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8535                                                 d_td->key.len,
8536                                                 d_td->iv.len) == 0)
8537                                 break;
8538                 }
8539         }
8540
8541         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8542                 return -ENOTSUP;
8543
8544         /* Setup source mbuf payload */
8545         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8546         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8547                         rte_pktmbuf_tailroom(ut_params->ibuf));
8548
8549         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8550                         d_td->ciphertext.len);
8551
8552         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
8553
8554         /* Setup cipher session parameters */
8555         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8556         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8557         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
8558         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8559         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8560         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8561         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8562         ut_params->cipher_xform.next = NULL;
8563
8564         /* Setup DOCSIS session parameters */
8565         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
8566
8567         struct rte_security_session_conf sess_conf = {
8568                 .action_type = ut_params->type,
8569                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8570                 .docsis = ut_params->docsis_xform,
8571                 .crypto_xform = &ut_params->cipher_xform,
8572         };
8573
8574         /* Create security session */
8575         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8576                                         ts_params->session_mpool,
8577                                         ts_params->session_priv_mpool);
8578
8579         if (!ut_params->sec_session) {
8580                 printf("TestCase %s(%d) line %d: %s\n",
8581                         __func__, i, __LINE__, "failed to allocate session");
8582                 ret = TEST_FAILED;
8583                 goto on_err;
8584         }
8585
8586         /* Generate crypto op data structure */
8587         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8588                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8589         if (!ut_params->op) {
8590                 printf("TestCase %s(%d) line %d: %s\n",
8591                         __func__, i, __LINE__,
8592                         "failed to allocate symmetric crypto operation");
8593                 ret = TEST_FAILED;
8594                 goto on_err;
8595         }
8596
8597         /* Setup CRC operation parameters */
8598         crc_len = d_td->ciphertext.no_crc == false ?
8599                         (d_td->ciphertext.len -
8600                                 d_td->ciphertext.crc_offset -
8601                                 RTE_ETHER_CRC_LEN) :
8602                         0;
8603         crc_len = crc_len > 0 ? crc_len : 0;
8604         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
8605         ut_params->op->sym->auth.data.length = crc_len;
8606         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
8607
8608         /* Setup cipher operation parameters */
8609         cipher_len = d_td->ciphertext.no_cipher == false ?
8610                         (d_td->ciphertext.len -
8611                                 d_td->ciphertext.cipher_offset) :
8612                         0;
8613         cipher_len = cipher_len > 0 ? cipher_len : 0;
8614         ut_params->op->sym->cipher.data.length = cipher_len;
8615         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
8616
8617         /* Setup cipher IV */
8618         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8619         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8620
8621         /* Attach session to operation */
8622         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8623
8624         /* Set crypto operation mbufs */
8625         ut_params->op->sym->m_src = ut_params->ibuf;
8626         ut_params->op->sym->m_dst = NULL;
8627
8628         /* Process crypto operation */
8629         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8630                         NULL) {
8631                 printf("TestCase %s(%d) line %d: %s\n",
8632                         __func__, i, __LINE__,
8633                         "failed to process security crypto op");
8634                 ret = TEST_FAILED;
8635                 goto on_err;
8636         }
8637
8638         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8639                 printf("TestCase %s(%d) line %d: %s\n",
8640                         __func__, i, __LINE__, "crypto op processing failed");
8641                 ret = TEST_FAILED;
8642                 goto on_err;
8643         }
8644
8645         /* Validate plaintext */
8646         plaintext = ciphertext;
8647
8648         if (memcmp(plaintext, d_td->plaintext.data,
8649                         d_td->plaintext.len - crc_data_len)) {
8650                 printf("TestCase %s(%d) line %d: %s\n",
8651                         __func__, i, __LINE__, "plaintext not as expected\n");
8652                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
8653                                 d_td->plaintext.len);
8654                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
8655                 ret = TEST_FAILED;
8656                 goto on_err;
8657         }
8658
8659 on_err:
8660         rte_crypto_op_free(ut_params->op);
8661         ut_params->op = NULL;
8662
8663         if (ut_params->sec_session)
8664                 rte_security_session_destroy(ctx, ut_params->sec_session);
8665         ut_params->sec_session = NULL;
8666
8667         rte_pktmbuf_free(ut_params->ibuf);
8668         ut_params->ibuf = NULL;
8669
8670         return ret;
8671 }
8672
8673 static int
8674 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
8675 {
8676         struct crypto_testsuite_params *ts_params = &testsuite_params;
8677         struct crypto_unittest_params *ut_params = &unittest_params;
8678         uint8_t *plaintext, *ciphertext;
8679         uint8_t *iv_ptr;
8680         int32_t cipher_len, crc_len;
8681         int ret = TEST_SUCCESS;
8682
8683         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8684                                         rte_cryptodev_get_sec_ctx(
8685                                                 ts_params->valid_devs[0]);
8686
8687         /* Verify the capabilities */
8688         struct rte_security_capability_idx sec_cap_idx;
8689         const struct rte_security_capability *sec_cap;
8690         const struct rte_cryptodev_capabilities *crypto_cap;
8691         const struct rte_cryptodev_symmetric_capability *sym_cap;
8692         int j = 0;
8693
8694         sec_cap_idx.action = ut_params->type;
8695         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8696         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8697
8698         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8699         if (sec_cap == NULL)
8700                 return -ENOTSUP;
8701
8702         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8703                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8704                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8705                                 crypto_cap->sym.xform_type ==
8706                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8707                                 crypto_cap->sym.cipher.algo ==
8708                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8709                         sym_cap = &crypto_cap->sym;
8710                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8711                                                 d_td->key.len,
8712                                                 d_td->iv.len) == 0)
8713                                 break;
8714                 }
8715         }
8716
8717         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8718                 return -ENOTSUP;
8719
8720         /* Setup source mbuf payload */
8721         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8722         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8723                         rte_pktmbuf_tailroom(ut_params->ibuf));
8724
8725         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8726                         d_td->plaintext.len);
8727
8728         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
8729
8730         /* Setup cipher session parameters */
8731         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8732         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8733         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8734         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8735         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8736         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8737         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8738         ut_params->cipher_xform.next = NULL;
8739
8740         /* Setup DOCSIS session parameters */
8741         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8742
8743         struct rte_security_session_conf sess_conf = {
8744                 .action_type = ut_params->type,
8745                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8746                 .docsis = ut_params->docsis_xform,
8747                 .crypto_xform = &ut_params->cipher_xform,
8748         };
8749
8750         /* Create security session */
8751         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8752                                         ts_params->session_mpool,
8753                                         ts_params->session_priv_mpool);
8754
8755         if (!ut_params->sec_session) {
8756                 printf("TestCase %s(%d) line %d: %s\n",
8757                         __func__, i, __LINE__, "failed to allocate session");
8758                 ret = TEST_FAILED;
8759                 goto on_err;
8760         }
8761
8762         /* Generate crypto op data structure */
8763         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8764                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8765         if (!ut_params->op) {
8766                 printf("TestCase %s(%d) line %d: %s\n",
8767                         __func__, i, __LINE__,
8768                         "failed to allocate security crypto operation");
8769                 ret = TEST_FAILED;
8770                 goto on_err;
8771         }
8772
8773         /* Setup CRC operation parameters */
8774         crc_len = d_td->plaintext.no_crc == false ?
8775                         (d_td->plaintext.len -
8776                                 d_td->plaintext.crc_offset -
8777                                 RTE_ETHER_CRC_LEN) :
8778                         0;
8779         crc_len = crc_len > 0 ? crc_len : 0;
8780         ut_params->op->sym->auth.data.length = crc_len;
8781         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
8782
8783         /* Setup cipher operation parameters */
8784         cipher_len = d_td->plaintext.no_cipher == false ?
8785                         (d_td->plaintext.len -
8786                                 d_td->plaintext.cipher_offset) :
8787                         0;
8788         cipher_len = cipher_len > 0 ? cipher_len : 0;
8789         ut_params->op->sym->cipher.data.length = cipher_len;
8790         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
8791
8792         /* Setup cipher IV */
8793         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8794         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8795
8796         /* Attach session to operation */
8797         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8798
8799         /* Set crypto operation mbufs */
8800         ut_params->op->sym->m_src = ut_params->ibuf;
8801         ut_params->op->sym->m_dst = NULL;
8802
8803         /* Process crypto operation */
8804         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8805                         NULL) {
8806                 printf("TestCase %s(%d) line %d: %s\n",
8807                         __func__, i, __LINE__,
8808                         "failed to process security crypto op");
8809                 ret = TEST_FAILED;
8810                 goto on_err;
8811         }
8812
8813         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8814                 printf("TestCase %s(%d) line %d: %s\n",
8815                         __func__, i, __LINE__, "crypto op processing failed");
8816                 ret = TEST_FAILED;
8817                 goto on_err;
8818         }
8819
8820         /* Validate ciphertext */
8821         ciphertext = plaintext;
8822
8823         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
8824                 printf("TestCase %s(%d) line %d: %s\n",
8825                         __func__, i, __LINE__, "ciphertext not as expected\n");
8826                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
8827                                 d_td->ciphertext.len);
8828                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
8829                 ret = TEST_FAILED;
8830                 goto on_err;
8831         }
8832
8833 on_err:
8834         rte_crypto_op_free(ut_params->op);
8835         ut_params->op = NULL;
8836
8837         if (ut_params->sec_session)
8838                 rte_security_session_destroy(ctx, ut_params->sec_session);
8839         ut_params->sec_session = NULL;
8840
8841         rte_pktmbuf_free(ut_params->ibuf);
8842         ut_params->ibuf = NULL;
8843
8844         return ret;
8845 }
8846
8847 #define TEST_DOCSIS_COUNT(func) do {                    \
8848         int ret = func;                                 \
8849         if (ret == TEST_SUCCESS)  {                     \
8850                 printf("\t%2d)", n++);                  \
8851                 printf("+++++ PASSED:" #func"\n");      \
8852                 p++;                                    \
8853         } else if (ret == -ENOTSUP) {                   \
8854                 printf("\t%2d)", n++);                  \
8855                 printf("~~~~~ UNSUPP:" #func"\n");      \
8856                 u++;                                    \
8857         } else {                                        \
8858                 printf("\t%2d)", n++);                  \
8859                 printf("----- FAILED:" #func"\n");      \
8860                 f++;                                    \
8861         }                                               \
8862 } while (0)
8863
8864 static int
8865 test_DOCSIS_PROTO_uplink_all(void)
8866 {
8867         int p = 0, u = 0, f = 0, n = 0;
8868
8869         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
8870         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
8871         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
8872         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
8873         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
8874         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
8875         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
8876         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
8877         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
8878         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
8879         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
8880         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
8881         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
8882         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
8883         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
8884         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
8885         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
8886         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
8887         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
8888         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
8889         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
8890         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
8891         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
8892         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
8893         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
8894         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
8895
8896         if (f)
8897                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8898                         __func__, p, n, u);
8899
8900         return f;
8901 };
8902
8903 static int
8904 test_DOCSIS_PROTO_downlink_all(void)
8905 {
8906         int p = 0, u = 0, f = 0, n = 0;
8907
8908         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
8909         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
8910         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
8911         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
8912         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
8913         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
8914         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
8915         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
8916         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
8917         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
8918         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
8919         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
8920         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
8921         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
8922         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
8923         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
8924         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
8925         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
8926         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
8927         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
8928         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
8929         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
8930         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
8931         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
8932         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
8933         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
8934
8935         if (f)
8936                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8937                         __func__, p, n, u);
8938
8939         return f;
8940 };
8941
8942 static int
8943 test_DOCSIS_PROTO_all(void)
8944 {
8945         struct crypto_testsuite_params *ts_params = &testsuite_params;
8946         struct crypto_unittest_params *ut_params = &unittest_params;
8947         struct rte_cryptodev_info dev_info;
8948         int status;
8949
8950         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8951         uint64_t feat_flags = dev_info.feature_flags;
8952
8953         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8954                 return -ENOTSUP;
8955
8956         /* Set action type */
8957         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8958                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8959                 gbl_action_type;
8960
8961         if (security_proto_supported(ut_params->type,
8962                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
8963                 return -ENOTSUP;
8964
8965         status = test_DOCSIS_PROTO_uplink_all();
8966         status += test_DOCSIS_PROTO_downlink_all();
8967
8968         if (status)
8969                 return TEST_FAILED;
8970         else
8971                 return TEST_SUCCESS;
8972 }
8973 #endif
8974
8975 static int
8976 test_AES_GCM_authenticated_encryption_test_case_1(void)
8977 {
8978         return test_authenticated_encryption(&gcm_test_case_1);
8979 }
8980
8981 static int
8982 test_AES_GCM_authenticated_encryption_test_case_2(void)
8983 {
8984         return test_authenticated_encryption(&gcm_test_case_2);
8985 }
8986
8987 static int
8988 test_AES_GCM_authenticated_encryption_test_case_3(void)
8989 {
8990         return test_authenticated_encryption(&gcm_test_case_3);
8991 }
8992
8993 static int
8994 test_AES_GCM_authenticated_encryption_test_case_4(void)
8995 {
8996         return test_authenticated_encryption(&gcm_test_case_4);
8997 }
8998
8999 static int
9000 test_AES_GCM_authenticated_encryption_test_case_5(void)
9001 {
9002         return test_authenticated_encryption(&gcm_test_case_5);
9003 }
9004
9005 static int
9006 test_AES_GCM_authenticated_encryption_test_case_6(void)
9007 {
9008         return test_authenticated_encryption(&gcm_test_case_6);
9009 }
9010
9011 static int
9012 test_AES_GCM_authenticated_encryption_test_case_7(void)
9013 {
9014         return test_authenticated_encryption(&gcm_test_case_7);
9015 }
9016
9017 static int
9018 test_AES_GCM_authenticated_encryption_test_case_8(void)
9019 {
9020         return test_authenticated_encryption(&gcm_test_case_8);
9021 }
9022
9023 static int
9024 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9025 {
9026         return test_authenticated_encryption(&gcm_J0_test_case_1);
9027 }
9028
9029 static int
9030 test_AES_GCM_auth_encryption_test_case_192_1(void)
9031 {
9032         return test_authenticated_encryption(&gcm_test_case_192_1);
9033 }
9034
9035 static int
9036 test_AES_GCM_auth_encryption_test_case_192_2(void)
9037 {
9038         return test_authenticated_encryption(&gcm_test_case_192_2);
9039 }
9040
9041 static int
9042 test_AES_GCM_auth_encryption_test_case_192_3(void)
9043 {
9044         return test_authenticated_encryption(&gcm_test_case_192_3);
9045 }
9046
9047 static int
9048 test_AES_GCM_auth_encryption_test_case_192_4(void)
9049 {
9050         return test_authenticated_encryption(&gcm_test_case_192_4);
9051 }
9052
9053 static int
9054 test_AES_GCM_auth_encryption_test_case_192_5(void)
9055 {
9056         return test_authenticated_encryption(&gcm_test_case_192_5);
9057 }
9058
9059 static int
9060 test_AES_GCM_auth_encryption_test_case_192_6(void)
9061 {
9062         return test_authenticated_encryption(&gcm_test_case_192_6);
9063 }
9064
9065 static int
9066 test_AES_GCM_auth_encryption_test_case_192_7(void)
9067 {
9068         return test_authenticated_encryption(&gcm_test_case_192_7);
9069 }
9070
9071 static int
9072 test_AES_GCM_auth_encryption_test_case_256_1(void)
9073 {
9074         return test_authenticated_encryption(&gcm_test_case_256_1);
9075 }
9076
9077 static int
9078 test_AES_GCM_auth_encryption_test_case_256_2(void)
9079 {
9080         return test_authenticated_encryption(&gcm_test_case_256_2);
9081 }
9082
9083 static int
9084 test_AES_GCM_auth_encryption_test_case_256_3(void)
9085 {
9086         return test_authenticated_encryption(&gcm_test_case_256_3);
9087 }
9088
9089 static int
9090 test_AES_GCM_auth_encryption_test_case_256_4(void)
9091 {
9092         return test_authenticated_encryption(&gcm_test_case_256_4);
9093 }
9094
9095 static int
9096 test_AES_GCM_auth_encryption_test_case_256_5(void)
9097 {
9098         return test_authenticated_encryption(&gcm_test_case_256_5);
9099 }
9100
9101 static int
9102 test_AES_GCM_auth_encryption_test_case_256_6(void)
9103 {
9104         return test_authenticated_encryption(&gcm_test_case_256_6);
9105 }
9106
9107 static int
9108 test_AES_GCM_auth_encryption_test_case_256_7(void)
9109 {
9110         return test_authenticated_encryption(&gcm_test_case_256_7);
9111 }
9112
9113 static int
9114 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9115 {
9116         return test_authenticated_encryption(&gcm_test_case_aad_1);
9117 }
9118
9119 static int
9120 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9121 {
9122         return test_authenticated_encryption(&gcm_test_case_aad_2);
9123 }
9124
9125 static int
9126 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9127 {
9128         struct aead_test_data tdata;
9129         int res;
9130
9131         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9132         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9133         tdata.iv.data[0] += 1;
9134         res = test_authenticated_encryption(&tdata);
9135         if (res == -ENOTSUP)
9136                 return res;
9137         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9138         return TEST_SUCCESS;
9139 }
9140
9141 static int
9142 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9143 {
9144         struct aead_test_data tdata;
9145         int res;
9146
9147         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9148         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9149         tdata.plaintext.data[0] += 1;
9150         res = test_authenticated_encryption(&tdata);
9151         if (res == -ENOTSUP)
9152                 return res;
9153         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9154         return TEST_SUCCESS;
9155 }
9156
9157 static int
9158 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9159 {
9160         struct aead_test_data tdata;
9161         int res;
9162
9163         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9164         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9165         tdata.ciphertext.data[0] += 1;
9166         res = test_authenticated_encryption(&tdata);
9167         if (res == -ENOTSUP)
9168                 return res;
9169         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9170         return TEST_SUCCESS;
9171 }
9172
9173 static int
9174 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9175 {
9176         struct aead_test_data tdata;
9177         int res;
9178
9179         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9180         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9181         tdata.aad.len += 1;
9182         res = test_authenticated_encryption(&tdata);
9183         if (res == -ENOTSUP)
9184                 return res;
9185         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9186         return TEST_SUCCESS;
9187 }
9188
9189 static int
9190 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9191 {
9192         struct aead_test_data tdata;
9193         uint8_t aad[gcm_test_case_7.aad.len];
9194         int res;
9195
9196         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9197         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9198         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9199         aad[0] += 1;
9200         tdata.aad.data = aad;
9201         res = test_authenticated_encryption(&tdata);
9202         if (res == -ENOTSUP)
9203                 return res;
9204         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9205         return TEST_SUCCESS;
9206 }
9207
9208 static int
9209 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9210 {
9211         struct aead_test_data tdata;
9212         int res;
9213
9214         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9215         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9216         tdata.auth_tag.data[0] += 1;
9217         res = test_authenticated_encryption(&tdata);
9218         if (res == -ENOTSUP)
9219                 return res;
9220         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9221         return TEST_SUCCESS;
9222 }
9223
9224 static int
9225 test_authenticated_decryption(const struct aead_test_data *tdata)
9226 {
9227         struct crypto_testsuite_params *ts_params = &testsuite_params;
9228         struct crypto_unittest_params *ut_params = &unittest_params;
9229
9230         int retval;
9231         uint8_t *plaintext;
9232         uint32_t i;
9233         struct rte_cryptodev_info dev_info;
9234
9235         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9236         uint64_t feat_flags = dev_info.feature_flags;
9237
9238         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9239                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9240                 printf("Device doesn't support RAW data-path APIs.\n");
9241                 return -ENOTSUP;
9242         }
9243
9244         /* Verify the capabilities */
9245         struct rte_cryptodev_sym_capability_idx cap_idx;
9246         const struct rte_cryptodev_symmetric_capability *capability;
9247         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9248         cap_idx.algo.aead = tdata->algo;
9249         capability = rte_cryptodev_sym_capability_get(
9250                         ts_params->valid_devs[0], &cap_idx);
9251         if (capability == NULL)
9252                 return -ENOTSUP;
9253         if (rte_cryptodev_sym_capability_check_aead(
9254                         capability, tdata->key.len, tdata->auth_tag.len,
9255                         tdata->aad.len, tdata->iv.len))
9256                 return -ENOTSUP;
9257
9258         /* Create AEAD session */
9259         retval = create_aead_session(ts_params->valid_devs[0],
9260                         tdata->algo,
9261                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9262                         tdata->key.data, tdata->key.len,
9263                         tdata->aad.len, tdata->auth_tag.len,
9264                         tdata->iv.len);
9265         if (retval < 0)
9266                 return retval;
9267
9268         /* alloc mbuf and set payload */
9269         if (tdata->aad.len > MBUF_SIZE) {
9270                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9271                 /* Populate full size of add data */
9272                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9273                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9274         } else
9275                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9276
9277         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9278                         rte_pktmbuf_tailroom(ut_params->ibuf));
9279
9280         /* Create AEAD operation */
9281         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9282         if (retval < 0)
9283                 return retval;
9284
9285         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9286
9287         ut_params->op->sym->m_src = ut_params->ibuf;
9288
9289         /* Process crypto operation */
9290         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9291                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9292         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9293                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9294                                 ut_params->op, 0, 0, 0, 0);
9295         else
9296                 TEST_ASSERT_NOT_NULL(
9297                         process_crypto_request(ts_params->valid_devs[0],
9298                         ut_params->op), "failed to process sym crypto op");
9299
9300         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9301                         "crypto op processing failed");
9302
9303         if (ut_params->op->sym->m_dst)
9304                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
9305                                 uint8_t *);
9306         else
9307                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
9308                                 uint8_t *,
9309                                 ut_params->op->sym->cipher.data.offset);
9310
9311         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9312
9313         /* Validate obuf */
9314         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9315                         plaintext,
9316                         tdata->plaintext.data,
9317                         tdata->plaintext.len,
9318                         "Plaintext data not as expected");
9319
9320         TEST_ASSERT_EQUAL(ut_params->op->status,
9321                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9322                         "Authentication failed");
9323
9324         return 0;
9325 }
9326
9327 static int
9328 test_AES_GCM_authenticated_decryption_test_case_1(void)
9329 {
9330         return test_authenticated_decryption(&gcm_test_case_1);
9331 }
9332
9333 static int
9334 test_AES_GCM_authenticated_decryption_test_case_2(void)
9335 {
9336         return test_authenticated_decryption(&gcm_test_case_2);
9337 }
9338
9339 static int
9340 test_AES_GCM_authenticated_decryption_test_case_3(void)
9341 {
9342         return test_authenticated_decryption(&gcm_test_case_3);
9343 }
9344
9345 static int
9346 test_AES_GCM_authenticated_decryption_test_case_4(void)
9347 {
9348         return test_authenticated_decryption(&gcm_test_case_4);
9349 }
9350
9351 static int
9352 test_AES_GCM_authenticated_decryption_test_case_5(void)
9353 {
9354         return test_authenticated_decryption(&gcm_test_case_5);
9355 }
9356
9357 static int
9358 test_AES_GCM_authenticated_decryption_test_case_6(void)
9359 {
9360         return test_authenticated_decryption(&gcm_test_case_6);
9361 }
9362
9363 static int
9364 test_AES_GCM_authenticated_decryption_test_case_7(void)
9365 {
9366         return test_authenticated_decryption(&gcm_test_case_7);
9367 }
9368
9369 static int
9370 test_AES_GCM_authenticated_decryption_test_case_8(void)
9371 {
9372         return test_authenticated_decryption(&gcm_test_case_8);
9373 }
9374
9375 static int
9376 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
9377 {
9378         return test_authenticated_decryption(&gcm_J0_test_case_1);
9379 }
9380
9381 static int
9382 test_AES_GCM_auth_decryption_test_case_192_1(void)
9383 {
9384         return test_authenticated_decryption(&gcm_test_case_192_1);
9385 }
9386
9387 static int
9388 test_AES_GCM_auth_decryption_test_case_192_2(void)
9389 {
9390         return test_authenticated_decryption(&gcm_test_case_192_2);
9391 }
9392
9393 static int
9394 test_AES_GCM_auth_decryption_test_case_192_3(void)
9395 {
9396         return test_authenticated_decryption(&gcm_test_case_192_3);
9397 }
9398
9399 static int
9400 test_AES_GCM_auth_decryption_test_case_192_4(void)
9401 {
9402         return test_authenticated_decryption(&gcm_test_case_192_4);
9403 }
9404
9405 static int
9406 test_AES_GCM_auth_decryption_test_case_192_5(void)
9407 {
9408         return test_authenticated_decryption(&gcm_test_case_192_5);
9409 }
9410
9411 static int
9412 test_AES_GCM_auth_decryption_test_case_192_6(void)
9413 {
9414         return test_authenticated_decryption(&gcm_test_case_192_6);
9415 }
9416
9417 static int
9418 test_AES_GCM_auth_decryption_test_case_192_7(void)
9419 {
9420         return test_authenticated_decryption(&gcm_test_case_192_7);
9421 }
9422
9423 static int
9424 test_AES_GCM_auth_decryption_test_case_256_1(void)
9425 {
9426         return test_authenticated_decryption(&gcm_test_case_256_1);
9427 }
9428
9429 static int
9430 test_AES_GCM_auth_decryption_test_case_256_2(void)
9431 {
9432         return test_authenticated_decryption(&gcm_test_case_256_2);
9433 }
9434
9435 static int
9436 test_AES_GCM_auth_decryption_test_case_256_3(void)
9437 {
9438         return test_authenticated_decryption(&gcm_test_case_256_3);
9439 }
9440
9441 static int
9442 test_AES_GCM_auth_decryption_test_case_256_4(void)
9443 {
9444         return test_authenticated_decryption(&gcm_test_case_256_4);
9445 }
9446
9447 static int
9448 test_AES_GCM_auth_decryption_test_case_256_5(void)
9449 {
9450         return test_authenticated_decryption(&gcm_test_case_256_5);
9451 }
9452
9453 static int
9454 test_AES_GCM_auth_decryption_test_case_256_6(void)
9455 {
9456         return test_authenticated_decryption(&gcm_test_case_256_6);
9457 }
9458
9459 static int
9460 test_AES_GCM_auth_decryption_test_case_256_7(void)
9461 {
9462         return test_authenticated_decryption(&gcm_test_case_256_7);
9463 }
9464
9465 static int
9466 test_AES_GCM_auth_decryption_test_case_aad_1(void)
9467 {
9468         return test_authenticated_decryption(&gcm_test_case_aad_1);
9469 }
9470
9471 static int
9472 test_AES_GCM_auth_decryption_test_case_aad_2(void)
9473 {
9474         return test_authenticated_decryption(&gcm_test_case_aad_2);
9475 }
9476
9477 static int
9478 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
9479 {
9480         struct aead_test_data tdata;
9481         int res;
9482
9483         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9484         tdata.iv.data[0] += 1;
9485         res = test_authenticated_decryption(&tdata);
9486         if (res == -ENOTSUP)
9487                 return res;
9488         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9489         return TEST_SUCCESS;
9490 }
9491
9492 static int
9493 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
9494 {
9495         struct aead_test_data tdata;
9496         int res;
9497
9498         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9499         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9500         tdata.plaintext.data[0] += 1;
9501         res = test_authenticated_decryption(&tdata);
9502         if (res == -ENOTSUP)
9503                 return res;
9504         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9505         return TEST_SUCCESS;
9506 }
9507
9508 static int
9509 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
9510 {
9511         struct aead_test_data tdata;
9512         int res;
9513
9514         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9515         tdata.ciphertext.data[0] += 1;
9516         res = test_authenticated_decryption(&tdata);
9517         if (res == -ENOTSUP)
9518                 return res;
9519         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9520         return TEST_SUCCESS;
9521 }
9522
9523 static int
9524 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
9525 {
9526         struct aead_test_data tdata;
9527         int res;
9528
9529         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9530         tdata.aad.len += 1;
9531         res = test_authenticated_decryption(&tdata);
9532         if (res == -ENOTSUP)
9533                 return res;
9534         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9535         return TEST_SUCCESS;
9536 }
9537
9538 static int
9539 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9540 {
9541         struct aead_test_data tdata;
9542         uint8_t aad[gcm_test_case_7.aad.len];
9543         int res;
9544
9545         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9546         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9547         aad[0] += 1;
9548         tdata.aad.data = aad;
9549         res = test_authenticated_decryption(&tdata);
9550         if (res == -ENOTSUP)
9551                 return res;
9552         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9553         return TEST_SUCCESS;
9554 }
9555
9556 static int
9557 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9558 {
9559         struct aead_test_data tdata;
9560         int res;
9561
9562         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9563         tdata.auth_tag.data[0] += 1;
9564         res = test_authenticated_decryption(&tdata);
9565         if (res == -ENOTSUP)
9566                 return res;
9567         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9568         return TEST_SUCCESS;
9569 }
9570
9571 static int
9572 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9573 {
9574         struct crypto_testsuite_params *ts_params = &testsuite_params;
9575         struct crypto_unittest_params *ut_params = &unittest_params;
9576
9577         int retval;
9578         uint8_t *ciphertext, *auth_tag;
9579         uint16_t plaintext_pad_len;
9580
9581         /* Verify the capabilities */
9582         struct rte_cryptodev_sym_capability_idx cap_idx;
9583         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9584         cap_idx.algo.aead = tdata->algo;
9585         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9586                         &cap_idx) == NULL)
9587                 return -ENOTSUP;
9588
9589         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9590                 return -ENOTSUP;
9591
9592         /* not supported with CPU crypto */
9593         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9594                 return -ENOTSUP;
9595
9596         /* Create AEAD session */
9597         retval = create_aead_session(ts_params->valid_devs[0],
9598                         tdata->algo,
9599                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9600                         tdata->key.data, tdata->key.len,
9601                         tdata->aad.len, tdata->auth_tag.len,
9602                         tdata->iv.len);
9603         if (retval < 0)
9604                 return retval;
9605
9606         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9607         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9608
9609         /* clear mbuf payload */
9610         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9611                         rte_pktmbuf_tailroom(ut_params->ibuf));
9612         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9613                         rte_pktmbuf_tailroom(ut_params->obuf));
9614
9615         /* Create AEAD operation */
9616         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9617         if (retval < 0)
9618                 return retval;
9619
9620         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9621
9622         ut_params->op->sym->m_src = ut_params->ibuf;
9623         ut_params->op->sym->m_dst = ut_params->obuf;
9624
9625         /* Process crypto operation */
9626         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9627                         ut_params->op), "failed to process sym crypto op");
9628
9629         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9630                         "crypto op processing failed");
9631
9632         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9633
9634         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9635                         ut_params->op->sym->cipher.data.offset);
9636         auth_tag = ciphertext + plaintext_pad_len;
9637
9638         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9639         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9640
9641         /* Validate obuf */
9642         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9643                         ciphertext,
9644                         tdata->ciphertext.data,
9645                         tdata->ciphertext.len,
9646                         "Ciphertext data not as expected");
9647
9648         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9649                         auth_tag,
9650                         tdata->auth_tag.data,
9651                         tdata->auth_tag.len,
9652                         "Generated auth tag not as expected");
9653
9654         return 0;
9655
9656 }
9657
9658 static int
9659 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
9660 {
9661         return test_authenticated_encryption_oop(&gcm_test_case_5);
9662 }
9663
9664 static int
9665 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
9666 {
9667         struct crypto_testsuite_params *ts_params = &testsuite_params;
9668         struct crypto_unittest_params *ut_params = &unittest_params;
9669
9670         int retval;
9671         uint8_t *plaintext;
9672
9673         /* Verify the capabilities */
9674         struct rte_cryptodev_sym_capability_idx cap_idx;
9675         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9676         cap_idx.algo.aead = tdata->algo;
9677         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9678                         &cap_idx) == NULL)
9679                 return -ENOTSUP;
9680
9681         /* not supported with CPU crypto and raw data-path APIs*/
9682         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
9683                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
9684                 return -ENOTSUP;
9685
9686         /* Create AEAD session */
9687         retval = create_aead_session(ts_params->valid_devs[0],
9688                         tdata->algo,
9689                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9690                         tdata->key.data, tdata->key.len,
9691                         tdata->aad.len, tdata->auth_tag.len,
9692                         tdata->iv.len);
9693         if (retval < 0)
9694                 return retval;
9695
9696         /* alloc mbuf and set payload */
9697         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9698         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9699
9700         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9701                         rte_pktmbuf_tailroom(ut_params->ibuf));
9702         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9703                         rte_pktmbuf_tailroom(ut_params->obuf));
9704
9705         /* Create AEAD operation */
9706         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9707         if (retval < 0)
9708                 return retval;
9709
9710         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9711
9712         ut_params->op->sym->m_src = ut_params->ibuf;
9713         ut_params->op->sym->m_dst = ut_params->obuf;
9714
9715         /* Process crypto operation */
9716         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9717                         ut_params->op), "failed to process sym crypto op");
9718
9719         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9720                         "crypto op processing failed");
9721
9722         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9723                         ut_params->op->sym->cipher.data.offset);
9724
9725         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9726
9727         /* Validate obuf */
9728         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9729                         plaintext,
9730                         tdata->plaintext.data,
9731                         tdata->plaintext.len,
9732                         "Plaintext data not as expected");
9733
9734         TEST_ASSERT_EQUAL(ut_params->op->status,
9735                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9736                         "Authentication failed");
9737         return 0;
9738 }
9739
9740 static int
9741 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
9742 {
9743         return test_authenticated_decryption_oop(&gcm_test_case_5);
9744 }
9745
9746 static int
9747 test_authenticated_encryption_sessionless(
9748                 const struct aead_test_data *tdata)
9749 {
9750         struct crypto_testsuite_params *ts_params = &testsuite_params;
9751         struct crypto_unittest_params *ut_params = &unittest_params;
9752
9753         int retval;
9754         uint8_t *ciphertext, *auth_tag;
9755         uint16_t plaintext_pad_len;
9756         uint8_t key[tdata->key.len + 1];
9757         struct rte_cryptodev_info dev_info;
9758
9759         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9760         uint64_t feat_flags = dev_info.feature_flags;
9761
9762         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9763                 printf("Device doesn't support Sessionless ops.\n");
9764                 return -ENOTSUP;
9765         }
9766
9767         /* not supported with CPU crypto */
9768         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9769                 return -ENOTSUP;
9770
9771         /* Verify the capabilities */
9772         struct rte_cryptodev_sym_capability_idx cap_idx;
9773         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9774         cap_idx.algo.aead = tdata->algo;
9775         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9776                         &cap_idx) == NULL)
9777                 return -ENOTSUP;
9778
9779         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9780
9781         /* clear mbuf payload */
9782         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9783                         rte_pktmbuf_tailroom(ut_params->ibuf));
9784
9785         /* Create AEAD operation */
9786         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9787         if (retval < 0)
9788                 return retval;
9789
9790         /* Create GCM xform */
9791         memcpy(key, tdata->key.data, tdata->key.len);
9792         retval = create_aead_xform(ut_params->op,
9793                         tdata->algo,
9794                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9795                         key, tdata->key.len,
9796                         tdata->aad.len, tdata->auth_tag.len,
9797                         tdata->iv.len);
9798         if (retval < 0)
9799                 return retval;
9800
9801         ut_params->op->sym->m_src = ut_params->ibuf;
9802
9803         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9804                         RTE_CRYPTO_OP_SESSIONLESS,
9805                         "crypto op session type not sessionless");
9806
9807         /* Process crypto operation */
9808         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9809                         ut_params->op), "failed to process sym crypto op");
9810
9811         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9812
9813         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9814                         "crypto op status not success");
9815
9816         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9817
9818         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9819                         ut_params->op->sym->cipher.data.offset);
9820         auth_tag = ciphertext + plaintext_pad_len;
9821
9822         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9823         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9824
9825         /* Validate obuf */
9826         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9827                         ciphertext,
9828                         tdata->ciphertext.data,
9829                         tdata->ciphertext.len,
9830                         "Ciphertext data not as expected");
9831
9832         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9833                         auth_tag,
9834                         tdata->auth_tag.data,
9835                         tdata->auth_tag.len,
9836                         "Generated auth tag not as expected");
9837
9838         return 0;
9839
9840 }
9841
9842 static int
9843 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9844 {
9845         return test_authenticated_encryption_sessionless(
9846                         &gcm_test_case_5);
9847 }
9848
9849 static int
9850 test_authenticated_decryption_sessionless(
9851                 const struct aead_test_data *tdata)
9852 {
9853         struct crypto_testsuite_params *ts_params = &testsuite_params;
9854         struct crypto_unittest_params *ut_params = &unittest_params;
9855
9856         int retval;
9857         uint8_t *plaintext;
9858         uint8_t key[tdata->key.len + 1];
9859         struct rte_cryptodev_info dev_info;
9860
9861         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9862         uint64_t feat_flags = dev_info.feature_flags;
9863
9864         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9865                 printf("Device doesn't support Sessionless ops.\n");
9866                 return -ENOTSUP;
9867         }
9868
9869         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9870                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9871                 printf("Device doesn't support RAW data-path APIs.\n");
9872                 return -ENOTSUP;
9873         }
9874
9875         /* not supported with CPU crypto */
9876         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9877                 return -ENOTSUP;
9878
9879         /* Verify the capabilities */
9880         struct rte_cryptodev_sym_capability_idx cap_idx;
9881         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9882         cap_idx.algo.aead = tdata->algo;
9883         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9884                         &cap_idx) == NULL)
9885                 return -ENOTSUP;
9886
9887         /* alloc mbuf and set payload */
9888         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9889
9890         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9891                         rte_pktmbuf_tailroom(ut_params->ibuf));
9892
9893         /* Create AEAD operation */
9894         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9895         if (retval < 0)
9896                 return retval;
9897
9898         /* Create AEAD xform */
9899         memcpy(key, tdata->key.data, tdata->key.len);
9900         retval = create_aead_xform(ut_params->op,
9901                         tdata->algo,
9902                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9903                         key, tdata->key.len,
9904                         tdata->aad.len, tdata->auth_tag.len,
9905                         tdata->iv.len);
9906         if (retval < 0)
9907                 return retval;
9908
9909         ut_params->op->sym->m_src = ut_params->ibuf;
9910
9911         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9912                         RTE_CRYPTO_OP_SESSIONLESS,
9913                         "crypto op session type not sessionless");
9914
9915         /* Process crypto operation */
9916         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9917                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9918                                 ut_params->op, 0, 0, 0, 0);
9919         else
9920                 TEST_ASSERT_NOT_NULL(process_crypto_request(
9921                         ts_params->valid_devs[0], ut_params->op),
9922                                 "failed to process sym crypto op");
9923
9924         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9925
9926         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9927                         "crypto op status not success");
9928
9929         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9930                         ut_params->op->sym->cipher.data.offset);
9931
9932         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9933
9934         /* Validate obuf */
9935         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9936                         plaintext,
9937                         tdata->plaintext.data,
9938                         tdata->plaintext.len,
9939                         "Plaintext data not as expected");
9940
9941         TEST_ASSERT_EQUAL(ut_params->op->status,
9942                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9943                         "Authentication failed");
9944         return 0;
9945 }
9946
9947 static int
9948 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9949 {
9950         return test_authenticated_decryption_sessionless(
9951                         &gcm_test_case_5);
9952 }
9953
9954 static int
9955 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9956 {
9957         return test_authenticated_encryption(&ccm_test_case_128_1);
9958 }
9959
9960 static int
9961 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9962 {
9963         return test_authenticated_encryption(&ccm_test_case_128_2);
9964 }
9965
9966 static int
9967 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9968 {
9969         return test_authenticated_encryption(&ccm_test_case_128_3);
9970 }
9971
9972 static int
9973 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9974 {
9975         return test_authenticated_decryption(&ccm_test_case_128_1);
9976 }
9977
9978 static int
9979 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9980 {
9981         return test_authenticated_decryption(&ccm_test_case_128_2);
9982 }
9983
9984 static int
9985 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9986 {
9987         return test_authenticated_decryption(&ccm_test_case_128_3);
9988 }
9989
9990 static int
9991 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9992 {
9993         return test_authenticated_encryption(&ccm_test_case_192_1);
9994 }
9995
9996 static int
9997 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9998 {
9999         return test_authenticated_encryption(&ccm_test_case_192_2);
10000 }
10001
10002 static int
10003 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10004 {
10005         return test_authenticated_encryption(&ccm_test_case_192_3);
10006 }
10007
10008 static int
10009 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10010 {
10011         return test_authenticated_decryption(&ccm_test_case_192_1);
10012 }
10013
10014 static int
10015 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10016 {
10017         return test_authenticated_decryption(&ccm_test_case_192_2);
10018 }
10019
10020 static int
10021 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10022 {
10023         return test_authenticated_decryption(&ccm_test_case_192_3);
10024 }
10025
10026 static int
10027 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10028 {
10029         return test_authenticated_encryption(&ccm_test_case_256_1);
10030 }
10031
10032 static int
10033 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10034 {
10035         return test_authenticated_encryption(&ccm_test_case_256_2);
10036 }
10037
10038 static int
10039 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10040 {
10041         return test_authenticated_encryption(&ccm_test_case_256_3);
10042 }
10043
10044 static int
10045 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10046 {
10047         return test_authenticated_decryption(&ccm_test_case_256_1);
10048 }
10049
10050 static int
10051 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10052 {
10053         return test_authenticated_decryption(&ccm_test_case_256_2);
10054 }
10055
10056 static int
10057 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10058 {
10059         return test_authenticated_decryption(&ccm_test_case_256_3);
10060 }
10061
10062 static int
10063 test_stats(void)
10064 {
10065         struct crypto_testsuite_params *ts_params = &testsuite_params;
10066         struct rte_cryptodev_stats stats;
10067
10068         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10069                 return -ENOTSUP;
10070
10071         /* Verify the capabilities */
10072         struct rte_cryptodev_sym_capability_idx cap_idx;
10073         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10074         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10075         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10076                         &cap_idx) == NULL)
10077                 return -ENOTSUP;
10078         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10079         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10080         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10081                         &cap_idx) == NULL)
10082                 return -ENOTSUP;
10083
10084         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10085                         == -ENOTSUP)
10086                 return -ENOTSUP;
10087
10088         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10089         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10090                         &stats) == -ENODEV),
10091                 "rte_cryptodev_stats_get invalid dev failed");
10092         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10093                 "rte_cryptodev_stats_get invalid Param failed");
10094
10095         /* Test expected values */
10096         test_AES_CBC_HMAC_SHA1_encrypt_digest();
10097         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10098                         &stats),
10099                 "rte_cryptodev_stats_get failed");
10100         TEST_ASSERT((stats.enqueued_count == 1),
10101                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10102         TEST_ASSERT((stats.dequeued_count == 1),
10103                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10104         TEST_ASSERT((stats.enqueue_err_count == 0),
10105                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10106         TEST_ASSERT((stats.dequeue_err_count == 0),
10107                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10108
10109         /* invalid device but should ignore and not reset device stats*/
10110         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10111         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10112                         &stats),
10113                 "rte_cryptodev_stats_get failed");
10114         TEST_ASSERT((stats.enqueued_count == 1),
10115                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10116
10117         /* check that a valid reset clears stats */
10118         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10119         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10120                         &stats),
10121                                           "rte_cryptodev_stats_get failed");
10122         TEST_ASSERT((stats.enqueued_count == 0),
10123                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10124         TEST_ASSERT((stats.dequeued_count == 0),
10125                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10126
10127         return TEST_SUCCESS;
10128 }
10129
10130 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10131                                    struct crypto_unittest_params *ut_params,
10132                                    enum rte_crypto_auth_operation op,
10133                                    const struct HMAC_MD5_vector *test_case)
10134 {
10135         uint8_t key[64];
10136
10137         memcpy(key, test_case->key.data, test_case->key.len);
10138
10139         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10140         ut_params->auth_xform.next = NULL;
10141         ut_params->auth_xform.auth.op = op;
10142
10143         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10144
10145         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10146         ut_params->auth_xform.auth.key.length = test_case->key.len;
10147         ut_params->auth_xform.auth.key.data = key;
10148
10149         ut_params->sess = rte_cryptodev_sym_session_create(
10150                         ts_params->session_mpool);
10151
10152         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10153                         ut_params->sess, &ut_params->auth_xform,
10154                         ts_params->session_priv_mpool);
10155
10156         if (ut_params->sess == NULL)
10157                 return TEST_FAILED;
10158
10159         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10160
10161         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10162                         rte_pktmbuf_tailroom(ut_params->ibuf));
10163
10164         return 0;
10165 }
10166
10167 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10168                               const struct HMAC_MD5_vector *test_case,
10169                               uint8_t **plaintext)
10170 {
10171         uint16_t plaintext_pad_len;
10172
10173         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10174
10175         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10176                                 16);
10177
10178         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10179                         plaintext_pad_len);
10180         memcpy(*plaintext, test_case->plaintext.data,
10181                         test_case->plaintext.len);
10182
10183         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10184                         ut_params->ibuf, MD5_DIGEST_LEN);
10185         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10186                         "no room to append digest");
10187         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10188                         ut_params->ibuf, plaintext_pad_len);
10189
10190         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10191                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10192                            test_case->auth_tag.len);
10193         }
10194
10195         sym_op->auth.data.offset = 0;
10196         sym_op->auth.data.length = test_case->plaintext.len;
10197
10198         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10199         ut_params->op->sym->m_src = ut_params->ibuf;
10200
10201         return 0;
10202 }
10203
10204 static int
10205 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10206 {
10207         uint16_t plaintext_pad_len;
10208         uint8_t *plaintext, *auth_tag;
10209
10210         struct crypto_testsuite_params *ts_params = &testsuite_params;
10211         struct crypto_unittest_params *ut_params = &unittest_params;
10212         struct rte_cryptodev_info dev_info;
10213
10214         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10215         uint64_t feat_flags = dev_info.feature_flags;
10216
10217         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10218                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10219                 printf("Device doesn't support RAW data-path APIs.\n");
10220                 return -ENOTSUP;
10221         }
10222
10223         /* Verify the capabilities */
10224         struct rte_cryptodev_sym_capability_idx cap_idx;
10225         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10226         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10227         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10228                         &cap_idx) == NULL)
10229                 return -ENOTSUP;
10230
10231         if (MD5_HMAC_create_session(ts_params, ut_params,
10232                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10233                 return TEST_FAILED;
10234
10235         /* Generate Crypto op data structure */
10236         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10237                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10238         TEST_ASSERT_NOT_NULL(ut_params->op,
10239                         "Failed to allocate symmetric crypto operation struct");
10240
10241         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10242                                 16);
10243
10244         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10245                 return TEST_FAILED;
10246
10247         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10248                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10249                         ut_params->op);
10250         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10251                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10252                                 ut_params->op, 0, 1, 0, 0);
10253         else
10254                 TEST_ASSERT_NOT_NULL(
10255                         process_crypto_request(ts_params->valid_devs[0],
10256                                 ut_params->op),
10257                                 "failed to process sym crypto op");
10258
10259         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10260                         "crypto op processing failed");
10261
10262         if (ut_params->op->sym->m_dst) {
10263                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10264                                 uint8_t *, plaintext_pad_len);
10265         } else {
10266                 auth_tag = plaintext + plaintext_pad_len;
10267         }
10268
10269         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10270                         auth_tag,
10271                         test_case->auth_tag.data,
10272                         test_case->auth_tag.len,
10273                         "HMAC_MD5 generated tag not as expected");
10274
10275         return TEST_SUCCESS;
10276 }
10277
10278 static int
10279 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10280 {
10281         uint8_t *plaintext;
10282
10283         struct crypto_testsuite_params *ts_params = &testsuite_params;
10284         struct crypto_unittest_params *ut_params = &unittest_params;
10285         struct rte_cryptodev_info dev_info;
10286
10287         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10288         uint64_t feat_flags = dev_info.feature_flags;
10289
10290         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10291                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10292                 printf("Device doesn't support RAW data-path APIs.\n");
10293                 return -ENOTSUP;
10294         }
10295
10296         /* Verify the capabilities */
10297         struct rte_cryptodev_sym_capability_idx cap_idx;
10298         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10299         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10300         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10301                         &cap_idx) == NULL)
10302                 return -ENOTSUP;
10303
10304         if (MD5_HMAC_create_session(ts_params, ut_params,
10305                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
10306                 return TEST_FAILED;
10307         }
10308
10309         /* Generate Crypto op data structure */
10310         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10311                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10312         TEST_ASSERT_NOT_NULL(ut_params->op,
10313                         "Failed to allocate symmetric crypto operation struct");
10314
10315         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10316                 return TEST_FAILED;
10317
10318         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10319                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10320                         ut_params->op);
10321         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10322                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10323                                 ut_params->op, 0, 1, 0, 0);
10324         else
10325                 TEST_ASSERT_NOT_NULL(
10326                         process_crypto_request(ts_params->valid_devs[0],
10327                                 ut_params->op),
10328                                 "failed to process sym crypto op");
10329
10330         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10331                         "HMAC_MD5 crypto op processing failed");
10332
10333         return TEST_SUCCESS;
10334 }
10335
10336 static int
10337 test_MD5_HMAC_generate_case_1(void)
10338 {
10339         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
10340 }
10341
10342 static int
10343 test_MD5_HMAC_verify_case_1(void)
10344 {
10345         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
10346 }
10347
10348 static int
10349 test_MD5_HMAC_generate_case_2(void)
10350 {
10351         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
10352 }
10353
10354 static int
10355 test_MD5_HMAC_verify_case_2(void)
10356 {
10357         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
10358 }
10359
10360 static int
10361 test_multi_session(void)
10362 {
10363         struct crypto_testsuite_params *ts_params = &testsuite_params;
10364         struct crypto_unittest_params *ut_params = &unittest_params;
10365
10366         struct rte_cryptodev_info dev_info;
10367         struct rte_cryptodev_sym_session **sessions;
10368
10369         uint16_t i;
10370
10371         /* Verify the capabilities */
10372         struct rte_cryptodev_sym_capability_idx cap_idx;
10373         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10374         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10375         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10376                         &cap_idx) == NULL)
10377                 return -ENOTSUP;
10378         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10379         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10380         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10381                         &cap_idx) == NULL)
10382                 return -ENOTSUP;
10383
10384         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
10385                         aes_cbc_key, hmac_sha512_key);
10386
10387
10388         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10389
10390         sessions = rte_malloc(NULL,
10391                         (sizeof(struct rte_cryptodev_sym_session *) *
10392                         MAX_NB_SESSIONS) + 1, 0);
10393
10394         /* Create multiple crypto sessions*/
10395         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10396
10397                 sessions[i] = rte_cryptodev_sym_session_create(
10398                                 ts_params->session_mpool);
10399
10400                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10401                                 sessions[i], &ut_params->auth_xform,
10402                                 ts_params->session_priv_mpool);
10403                 TEST_ASSERT_NOT_NULL(sessions[i],
10404                                 "Session creation failed at session number %u",
10405                                 i);
10406
10407                 /* Attempt to send a request on each session */
10408                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
10409                         sessions[i],
10410                         ut_params,
10411                         ts_params,
10412                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
10413                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
10414                         aes_cbc_iv),
10415                         "Failed to perform decrypt on request number %u.", i);
10416                 /* free crypto operation structure */
10417                 if (ut_params->op)
10418                         rte_crypto_op_free(ut_params->op);
10419
10420                 /*
10421                  * free mbuf - both obuf and ibuf are usually the same,
10422                  * so check if they point at the same address is necessary,
10423                  * to avoid freeing the mbuf twice.
10424                  */
10425                 if (ut_params->obuf) {
10426                         rte_pktmbuf_free(ut_params->obuf);
10427                         if (ut_params->ibuf == ut_params->obuf)
10428                                 ut_params->ibuf = 0;
10429                         ut_params->obuf = 0;
10430                 }
10431                 if (ut_params->ibuf) {
10432                         rte_pktmbuf_free(ut_params->ibuf);
10433                         ut_params->ibuf = 0;
10434                 }
10435         }
10436
10437         /* Next session create should fail */
10438         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10439                         sessions[i], &ut_params->auth_xform,
10440                         ts_params->session_priv_mpool);
10441         TEST_ASSERT_NULL(sessions[i],
10442                         "Session creation succeeded unexpectedly!");
10443
10444         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10445                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10446                                 sessions[i]);
10447                 rte_cryptodev_sym_session_free(sessions[i]);
10448         }
10449
10450         rte_free(sessions);
10451
10452         return TEST_SUCCESS;
10453 }
10454
10455 struct multi_session_params {
10456         struct crypto_unittest_params ut_params;
10457         uint8_t *cipher_key;
10458         uint8_t *hmac_key;
10459         const uint8_t *cipher;
10460         const uint8_t *digest;
10461         uint8_t *iv;
10462 };
10463
10464 #define MB_SESSION_NUMBER 3
10465
10466 static int
10467 test_multi_session_random_usage(void)
10468 {
10469         struct crypto_testsuite_params *ts_params = &testsuite_params;
10470         struct rte_cryptodev_info dev_info;
10471         struct rte_cryptodev_sym_session **sessions;
10472         uint32_t i, j;
10473         struct multi_session_params ut_paramz[] = {
10474
10475                 {
10476                         .cipher_key = ms_aes_cbc_key0,
10477                         .hmac_key = ms_hmac_key0,
10478                         .cipher = ms_aes_cbc_cipher0,
10479                         .digest = ms_hmac_digest0,
10480                         .iv = ms_aes_cbc_iv0
10481                 },
10482                 {
10483                         .cipher_key = ms_aes_cbc_key1,
10484                         .hmac_key = ms_hmac_key1,
10485                         .cipher = ms_aes_cbc_cipher1,
10486                         .digest = ms_hmac_digest1,
10487                         .iv = ms_aes_cbc_iv1
10488                 },
10489                 {
10490                         .cipher_key = ms_aes_cbc_key2,
10491                         .hmac_key = ms_hmac_key2,
10492                         .cipher = ms_aes_cbc_cipher2,
10493                         .digest = ms_hmac_digest2,
10494                         .iv = ms_aes_cbc_iv2
10495                 },
10496
10497         };
10498
10499         /* Verify the capabilities */
10500         struct rte_cryptodev_sym_capability_idx cap_idx;
10501         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10502         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10503         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10504                         &cap_idx) == NULL)
10505                 return -ENOTSUP;
10506         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10507         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10508         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10509                         &cap_idx) == NULL)
10510                 return -ENOTSUP;
10511
10512         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10513
10514         sessions = rte_malloc(NULL,
10515                         (sizeof(struct rte_cryptodev_sym_session *)
10516                                         * MAX_NB_SESSIONS) + 1, 0);
10517
10518         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10519                 sessions[i] = rte_cryptodev_sym_session_create(
10520                                 ts_params->session_mpool);
10521
10522                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
10523                                 sizeof(struct crypto_unittest_params));
10524
10525                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
10526                                 &ut_paramz[i].ut_params,
10527                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
10528
10529                 /* Create multiple crypto sessions*/
10530                 rte_cryptodev_sym_session_init(
10531                                 ts_params->valid_devs[0],
10532                                 sessions[i],
10533                                 &ut_paramz[i].ut_params.auth_xform,
10534                                 ts_params->session_priv_mpool);
10535
10536                 TEST_ASSERT_NOT_NULL(sessions[i],
10537                                 "Session creation failed at session number %u",
10538                                 i);
10539
10540         }
10541
10542         srand(time(NULL));
10543         for (i = 0; i < 40000; i++) {
10544
10545                 j = rand() % MB_SESSION_NUMBER;
10546
10547                 TEST_ASSERT_SUCCESS(
10548                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
10549                                         sessions[j],
10550                                         &ut_paramz[j].ut_params,
10551                                         ts_params, ut_paramz[j].cipher,
10552                                         ut_paramz[j].digest,
10553                                         ut_paramz[j].iv),
10554                         "Failed to perform decrypt on request number %u.", i);
10555
10556                 if (ut_paramz[j].ut_params.op)
10557                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
10558
10559                 /*
10560                  * free mbuf - both obuf and ibuf are usually the same,
10561                  * so check if they point at the same address is necessary,
10562                  * to avoid freeing the mbuf twice.
10563                  */
10564                 if (ut_paramz[j].ut_params.obuf) {
10565                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
10566                         if (ut_paramz[j].ut_params.ibuf
10567                                         == ut_paramz[j].ut_params.obuf)
10568                                 ut_paramz[j].ut_params.ibuf = 0;
10569                         ut_paramz[j].ut_params.obuf = 0;
10570                 }
10571                 if (ut_paramz[j].ut_params.ibuf) {
10572                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
10573                         ut_paramz[j].ut_params.ibuf = 0;
10574                 }
10575         }
10576
10577         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10578                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10579                                 sessions[i]);
10580                 rte_cryptodev_sym_session_free(sessions[i]);
10581         }
10582
10583         rte_free(sessions);
10584
10585         return TEST_SUCCESS;
10586 }
10587
10588 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
10589                         0xab, 0xab, 0xab, 0xab,
10590                         0xab, 0xab, 0xab, 0xab,
10591                         0xab, 0xab, 0xab, 0xab};
10592
10593 static int
10594 test_null_invalid_operation(void)
10595 {
10596         struct crypto_testsuite_params *ts_params = &testsuite_params;
10597         struct crypto_unittest_params *ut_params = &unittest_params;
10598         int ret;
10599
10600         /* This test is for NULL PMD only */
10601         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10602                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10603                 return -ENOTSUP;
10604
10605         /* Setup Cipher Parameters */
10606         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10607         ut_params->cipher_xform.next = NULL;
10608
10609         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10610         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10611
10612         ut_params->sess = rte_cryptodev_sym_session_create(
10613                         ts_params->session_mpool);
10614
10615         /* Create Crypto session*/
10616         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10617                         ut_params->sess, &ut_params->cipher_xform,
10618                         ts_params->session_priv_mpool);
10619         TEST_ASSERT(ret < 0,
10620                         "Session creation succeeded unexpectedly");
10621
10622
10623         /* Setup HMAC Parameters */
10624         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10625         ut_params->auth_xform.next = NULL;
10626
10627         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10628         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10629
10630         ut_params->sess = rte_cryptodev_sym_session_create(
10631                         ts_params->session_mpool);
10632
10633         /* Create Crypto session*/
10634         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10635                         ut_params->sess, &ut_params->auth_xform,
10636                         ts_params->session_priv_mpool);
10637         TEST_ASSERT(ret < 0,
10638                         "Session creation succeeded unexpectedly");
10639
10640         return TEST_SUCCESS;
10641 }
10642
10643
10644 #define NULL_BURST_LENGTH (32)
10645
10646 static int
10647 test_null_burst_operation(void)
10648 {
10649         struct crypto_testsuite_params *ts_params = &testsuite_params;
10650         struct crypto_unittest_params *ut_params = &unittest_params;
10651
10652         unsigned i, burst_len = NULL_BURST_LENGTH;
10653
10654         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10655         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10656
10657         /* This test is for NULL PMD only */
10658         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10659                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10660                 return -ENOTSUP;
10661
10662         /* Setup Cipher Parameters */
10663         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10664         ut_params->cipher_xform.next = &ut_params->auth_xform;
10665
10666         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10667         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10668
10669         /* Setup HMAC Parameters */
10670         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10671         ut_params->auth_xform.next = NULL;
10672
10673         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10674         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10675
10676         ut_params->sess = rte_cryptodev_sym_session_create(
10677                         ts_params->session_mpool);
10678
10679         /* Create Crypto session*/
10680         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10681                         ut_params->sess, &ut_params->cipher_xform,
10682                         ts_params->session_priv_mpool);
10683         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10684
10685         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10686                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10687                         burst_len, "failed to generate burst of crypto ops");
10688
10689         /* Generate an operation for each mbuf in burst */
10690         for (i = 0; i < burst_len; i++) {
10691                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10692
10693                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10694
10695                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10696                                 sizeof(unsigned));
10697                 *data = i;
10698
10699                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10700
10701                 burst[i]->sym->m_src = m;
10702         }
10703
10704         /* Process crypto operation */
10705         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10706                         0, burst, burst_len),
10707                         burst_len,
10708                         "Error enqueuing burst");
10709
10710         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10711                         0, burst_dequeued, burst_len),
10712                         burst_len,
10713                         "Error dequeuing burst");
10714
10715
10716         for (i = 0; i < burst_len; i++) {
10717                 TEST_ASSERT_EQUAL(
10718                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10719                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10720                                         uint32_t *),
10721                         "data not as expected");
10722
10723                 rte_pktmbuf_free(burst[i]->sym->m_src);
10724                 rte_crypto_op_free(burst[i]);
10725         }
10726
10727         return TEST_SUCCESS;
10728 }
10729
10730 static uint16_t
10731 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
10732                   uint16_t nb_ops, void *user_param)
10733 {
10734         RTE_SET_USED(dev_id);
10735         RTE_SET_USED(qp_id);
10736         RTE_SET_USED(ops);
10737         RTE_SET_USED(user_param);
10738
10739         printf("crypto enqueue callback called\n");
10740         return nb_ops;
10741 }
10742
10743 static uint16_t
10744 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
10745                   uint16_t nb_ops, void *user_param)
10746 {
10747         RTE_SET_USED(dev_id);
10748         RTE_SET_USED(qp_id);
10749         RTE_SET_USED(ops);
10750         RTE_SET_USED(user_param);
10751
10752         printf("crypto dequeue callback called\n");
10753         return nb_ops;
10754 }
10755
10756 /*
10757  * Thread using enqueue/dequeue callback with RCU.
10758  */
10759 static int
10760 test_enqdeq_callback_thread(void *arg)
10761 {
10762         RTE_SET_USED(arg);
10763         /* DP thread calls rte_cryptodev_enqueue_burst()/
10764          * rte_cryptodev_dequeue_burst() and invokes callback.
10765          */
10766         test_null_burst_operation();
10767         return 0;
10768 }
10769
10770 static int
10771 test_enq_callback_setup(void)
10772 {
10773         struct crypto_testsuite_params *ts_params = &testsuite_params;
10774         struct rte_cryptodev_info dev_info;
10775         struct rte_cryptodev_qp_conf qp_conf = {
10776                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
10777         };
10778
10779         struct rte_cryptodev_cb *cb;
10780         uint16_t qp_id = 0;
10781
10782         /* Stop the device in case it's started so it can be configured */
10783         rte_cryptodev_stop(ts_params->valid_devs[0]);
10784
10785         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10786
10787         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
10788                         &ts_params->conf),
10789                         "Failed to configure cryptodev %u",
10790                         ts_params->valid_devs[0]);
10791
10792         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
10793         qp_conf.mp_session = ts_params->session_mpool;
10794         qp_conf.mp_session_private = ts_params->session_priv_mpool;
10795
10796         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
10797                         ts_params->valid_devs[0], qp_id, &qp_conf,
10798                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
10799                         "Failed test for "
10800                         "rte_cryptodev_queue_pair_setup: num_inflights "
10801                         "%u on qp %u on cryptodev %u",
10802                         qp_conf.nb_descriptors, qp_id,
10803                         ts_params->valid_devs[0]);
10804
10805         /* Test with invalid crypto device */
10806         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
10807                         qp_id, test_enq_callback, NULL);
10808         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10809                         "cryptodev %u did not fail",
10810                         qp_id, RTE_CRYPTO_MAX_DEVS);
10811
10812         /* Test with invalid queue pair */
10813         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
10814                         dev_info.max_nb_queue_pairs + 1,
10815                         test_enq_callback, NULL);
10816         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10817                         "cryptodev %u did not fail",
10818                         dev_info.max_nb_queue_pairs + 1,
10819                         ts_params->valid_devs[0]);
10820
10821         /* Test with NULL callback */
10822         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
10823                         qp_id, NULL, NULL);
10824         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10825                         "cryptodev %u did not fail",
10826                         qp_id, ts_params->valid_devs[0]);
10827
10828         /* Test with valid configuration */
10829         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
10830                         qp_id, test_enq_callback, NULL);
10831         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
10832                         "qp %u on cryptodev %u",
10833                         qp_id, ts_params->valid_devs[0]);
10834
10835         rte_cryptodev_start(ts_params->valid_devs[0]);
10836
10837         /* Launch a thread */
10838         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
10839                                 rte_get_next_lcore(-1, 1, 0));
10840
10841         /* Wait until reader exited. */
10842         rte_eal_mp_wait_lcore();
10843
10844         /* Test with invalid crypto device */
10845         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
10846                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
10847                         "Expected call to fail as crypto device is invalid");
10848
10849         /* Test with invalid queue pair */
10850         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
10851                         ts_params->valid_devs[0],
10852                         dev_info.max_nb_queue_pairs + 1, cb),
10853                         "Expected call to fail as queue pair is invalid");
10854
10855         /* Test with NULL callback */
10856         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
10857                         ts_params->valid_devs[0], qp_id, NULL),
10858                         "Expected call to fail as callback is NULL");
10859
10860         /* Test with valid configuration */
10861         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
10862                         ts_params->valid_devs[0], qp_id, cb),
10863                         "Failed test to remove callback on "
10864                         "qp %u on cryptodev %u",
10865                         qp_id, ts_params->valid_devs[0]);
10866
10867         return TEST_SUCCESS;
10868 }
10869
10870 static int
10871 test_deq_callback_setup(void)
10872 {
10873         struct crypto_testsuite_params *ts_params = &testsuite_params;
10874         struct rte_cryptodev_info dev_info;
10875         struct rte_cryptodev_qp_conf qp_conf = {
10876                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
10877         };
10878
10879         struct rte_cryptodev_cb *cb;
10880         uint16_t qp_id = 0;
10881
10882         /* Stop the device in case it's started so it can be configured */
10883         rte_cryptodev_stop(ts_params->valid_devs[0]);
10884
10885         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10886
10887         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
10888                         &ts_params->conf),
10889                         "Failed to configure cryptodev %u",
10890                         ts_params->valid_devs[0]);
10891
10892         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
10893         qp_conf.mp_session = ts_params->session_mpool;
10894         qp_conf.mp_session_private = ts_params->session_priv_mpool;
10895
10896         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
10897                         ts_params->valid_devs[0], qp_id, &qp_conf,
10898                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
10899                         "Failed test for "
10900                         "rte_cryptodev_queue_pair_setup: num_inflights "
10901                         "%u on qp %u on cryptodev %u",
10902                         qp_conf.nb_descriptors, qp_id,
10903                         ts_params->valid_devs[0]);
10904
10905         /* Test with invalid crypto device */
10906         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
10907                         qp_id, test_deq_callback, NULL);
10908         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10909                         "cryptodev %u did not fail",
10910                         qp_id, RTE_CRYPTO_MAX_DEVS);
10911
10912         /* Test with invalid queue pair */
10913         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
10914                         dev_info.max_nb_queue_pairs + 1,
10915                         test_deq_callback, NULL);
10916         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10917                         "cryptodev %u did not fail",
10918                         dev_info.max_nb_queue_pairs + 1,
10919                         ts_params->valid_devs[0]);
10920
10921         /* Test with NULL callback */
10922         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
10923                         qp_id, NULL, NULL);
10924         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
10925                         "cryptodev %u did not fail",
10926                         qp_id, ts_params->valid_devs[0]);
10927
10928         /* Test with valid configuration */
10929         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
10930                         qp_id, test_deq_callback, NULL);
10931         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
10932                         "qp %u on cryptodev %u",
10933                         qp_id, ts_params->valid_devs[0]);
10934
10935         rte_cryptodev_start(ts_params->valid_devs[0]);
10936
10937         /* Launch a thread */
10938         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
10939                                 rte_get_next_lcore(-1, 1, 0));
10940
10941         /* Wait until reader exited. */
10942         rte_eal_mp_wait_lcore();
10943
10944         /* Test with invalid crypto device */
10945         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
10946                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
10947                         "Expected call to fail as crypto device is invalid");
10948
10949         /* Test with invalid queue pair */
10950         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
10951                         ts_params->valid_devs[0],
10952                         dev_info.max_nb_queue_pairs + 1, cb),
10953                         "Expected call to fail as queue pair is invalid");
10954
10955         /* Test with NULL callback */
10956         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
10957                         ts_params->valid_devs[0], qp_id, NULL),
10958                         "Expected call to fail as callback is NULL");
10959
10960         /* Test with valid configuration */
10961         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
10962                         ts_params->valid_devs[0], qp_id, cb),
10963                         "Failed test to remove callback on "
10964                         "qp %u on cryptodev %u",
10965                         qp_id, ts_params->valid_devs[0]);
10966
10967         return TEST_SUCCESS;
10968 }
10969
10970 static void
10971 generate_gmac_large_plaintext(uint8_t *data)
10972 {
10973         uint16_t i;
10974
10975         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10976                 memcpy(&data[i], &data[0], 32);
10977 }
10978
10979 static int
10980 create_gmac_operation(enum rte_crypto_auth_operation op,
10981                 const struct gmac_test_data *tdata)
10982 {
10983         struct crypto_testsuite_params *ts_params = &testsuite_params;
10984         struct crypto_unittest_params *ut_params = &unittest_params;
10985         struct rte_crypto_sym_op *sym_op;
10986
10987         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10988
10989         /* Generate Crypto op data structure */
10990         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10991                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10992         TEST_ASSERT_NOT_NULL(ut_params->op,
10993                         "Failed to allocate symmetric crypto operation struct");
10994
10995         sym_op = ut_params->op->sym;
10996
10997         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10998                         ut_params->ibuf, tdata->gmac_tag.len);
10999         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11000                         "no room to append digest");
11001
11002         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11003                         ut_params->ibuf, plaintext_pad_len);
11004
11005         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11006                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11007                                 tdata->gmac_tag.len);
11008                 debug_hexdump(stdout, "digest:",
11009                                 sym_op->auth.digest.data,
11010                                 tdata->gmac_tag.len);
11011         }
11012
11013         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11014                         uint8_t *, IV_OFFSET);
11015
11016         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11017
11018         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11019
11020         sym_op->cipher.data.length = 0;
11021         sym_op->cipher.data.offset = 0;
11022
11023         sym_op->auth.data.offset = 0;
11024         sym_op->auth.data.length = tdata->plaintext.len;
11025
11026         return 0;
11027 }
11028
11029 static int
11030 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
11031                 const struct gmac_test_data *tdata,
11032                 void *digest_mem, uint64_t digest_phys)
11033 {
11034         struct crypto_testsuite_params *ts_params = &testsuite_params;
11035         struct crypto_unittest_params *ut_params = &unittest_params;
11036         struct rte_crypto_sym_op *sym_op;
11037
11038         /* Generate Crypto op data structure */
11039         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11040                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11041         TEST_ASSERT_NOT_NULL(ut_params->op,
11042                         "Failed to allocate symmetric crypto operation struct");
11043
11044         sym_op = ut_params->op->sym;
11045
11046         sym_op->auth.digest.data = digest_mem;
11047         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11048                         "no room to append digest");
11049
11050         sym_op->auth.digest.phys_addr = digest_phys;
11051
11052         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11053                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
11054                                 tdata->gmac_tag.len);
11055                 debug_hexdump(stdout, "digest:",
11056                                 sym_op->auth.digest.data,
11057                                 tdata->gmac_tag.len);
11058         }
11059
11060         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
11061                         uint8_t *, IV_OFFSET);
11062
11063         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
11064
11065         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
11066
11067         sym_op->cipher.data.length = 0;
11068         sym_op->cipher.data.offset = 0;
11069
11070         sym_op->auth.data.offset = 0;
11071         sym_op->auth.data.length = tdata->plaintext.len;
11072
11073         return 0;
11074 }
11075
11076 static int create_gmac_session(uint8_t dev_id,
11077                 const struct gmac_test_data *tdata,
11078                 enum rte_crypto_auth_operation auth_op)
11079 {
11080         uint8_t auth_key[tdata->key.len];
11081
11082         struct crypto_testsuite_params *ts_params = &testsuite_params;
11083         struct crypto_unittest_params *ut_params = &unittest_params;
11084
11085         memcpy(auth_key, tdata->key.data, tdata->key.len);
11086
11087         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11088         ut_params->auth_xform.next = NULL;
11089
11090         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
11091         ut_params->auth_xform.auth.op = auth_op;
11092         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
11093         ut_params->auth_xform.auth.key.length = tdata->key.len;
11094         ut_params->auth_xform.auth.key.data = auth_key;
11095         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11096         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
11097
11098
11099         ut_params->sess = rte_cryptodev_sym_session_create(
11100                         ts_params->session_mpool);
11101
11102         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11103                         &ut_params->auth_xform,
11104                         ts_params->session_priv_mpool);
11105
11106         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11107
11108         return 0;
11109 }
11110
11111 static int
11112 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
11113 {
11114         struct crypto_testsuite_params *ts_params = &testsuite_params;
11115         struct crypto_unittest_params *ut_params = &unittest_params;
11116         struct rte_cryptodev_info dev_info;
11117
11118         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11119         uint64_t feat_flags = dev_info.feature_flags;
11120
11121         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11122                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11123                 printf("Device doesn't support RAW data-path APIs.\n");
11124                 return -ENOTSUP;
11125         }
11126
11127         int retval;
11128
11129         uint8_t *auth_tag, *plaintext;
11130         uint16_t plaintext_pad_len;
11131
11132         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11133                               "No GMAC length in the source data");
11134
11135         /* Verify the capabilities */
11136         struct rte_cryptodev_sym_capability_idx cap_idx;
11137         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11138         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11139         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11140                         &cap_idx) == NULL)
11141                 return -ENOTSUP;
11142
11143         retval = create_gmac_session(ts_params->valid_devs[0],
11144                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11145
11146         if (retval < 0)
11147                 return retval;
11148
11149         if (tdata->plaintext.len > MBUF_SIZE)
11150                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11151         else
11152                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11153         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11154                         "Failed to allocate input buffer in mempool");
11155
11156         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11157                         rte_pktmbuf_tailroom(ut_params->ibuf));
11158
11159         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11160         /*
11161          * Runtime generate the large plain text instead of use hard code
11162          * plain text vector. It is done to avoid create huge source file
11163          * with the test vector.
11164          */
11165         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11166                 generate_gmac_large_plaintext(tdata->plaintext.data);
11167
11168         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11169                                 plaintext_pad_len);
11170         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11171
11172         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11173         debug_hexdump(stdout, "plaintext:", plaintext,
11174                         tdata->plaintext.len);
11175
11176         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
11177                         tdata);
11178
11179         if (retval < 0)
11180                 return retval;
11181
11182         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11183
11184         ut_params->op->sym->m_src = ut_params->ibuf;
11185
11186         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11187                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11188                         ut_params->op);
11189         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11190                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11191                                 ut_params->op, 0, 1, 0, 0);
11192         else
11193                 TEST_ASSERT_NOT_NULL(
11194                         process_crypto_request(ts_params->valid_devs[0],
11195                         ut_params->op), "failed to process sym crypto op");
11196
11197         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11198                         "crypto op processing failed");
11199
11200         if (ut_params->op->sym->m_dst) {
11201                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11202                                 uint8_t *, plaintext_pad_len);
11203         } else {
11204                 auth_tag = plaintext + plaintext_pad_len;
11205         }
11206
11207         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11208
11209         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11210                         auth_tag,
11211                         tdata->gmac_tag.data,
11212                         tdata->gmac_tag.len,
11213                         "GMAC Generated auth tag not as expected");
11214
11215         return 0;
11216 }
11217
11218 static int
11219 test_AES_GMAC_authentication_test_case_1(void)
11220 {
11221         return test_AES_GMAC_authentication(&gmac_test_case_1);
11222 }
11223
11224 static int
11225 test_AES_GMAC_authentication_test_case_2(void)
11226 {
11227         return test_AES_GMAC_authentication(&gmac_test_case_2);
11228 }
11229
11230 static int
11231 test_AES_GMAC_authentication_test_case_3(void)
11232 {
11233         return test_AES_GMAC_authentication(&gmac_test_case_3);
11234 }
11235
11236 static int
11237 test_AES_GMAC_authentication_test_case_4(void)
11238 {
11239         return test_AES_GMAC_authentication(&gmac_test_case_4);
11240 }
11241
11242 static int
11243 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11244 {
11245         struct crypto_testsuite_params *ts_params = &testsuite_params;
11246         struct crypto_unittest_params *ut_params = &unittest_params;
11247         int retval;
11248         uint32_t plaintext_pad_len;
11249         uint8_t *plaintext;
11250         struct rte_cryptodev_info dev_info;
11251
11252         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11253         uint64_t feat_flags = dev_info.feature_flags;
11254
11255         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11256                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11257                 printf("Device doesn't support RAW data-path APIs.\n");
11258                 return -ENOTSUP;
11259         }
11260
11261         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11262                               "No GMAC length in the source data");
11263
11264         /* Verify the capabilities */
11265         struct rte_cryptodev_sym_capability_idx cap_idx;
11266         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11267         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11268         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11269                         &cap_idx) == NULL)
11270                 return -ENOTSUP;
11271
11272         retval = create_gmac_session(ts_params->valid_devs[0],
11273                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11274
11275         if (retval < 0)
11276                 return retval;
11277
11278         if (tdata->plaintext.len > MBUF_SIZE)
11279                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11280         else
11281                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11282         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11283                         "Failed to allocate input buffer in mempool");
11284
11285         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11286                         rte_pktmbuf_tailroom(ut_params->ibuf));
11287
11288         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11289
11290         /*
11291          * Runtime generate the large plain text instead of use hard code
11292          * plain text vector. It is done to avoid create huge source file
11293          * with the test vector.
11294          */
11295         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11296                 generate_gmac_large_plaintext(tdata->plaintext.data);
11297
11298         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11299                                 plaintext_pad_len);
11300         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11301
11302         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11303         debug_hexdump(stdout, "plaintext:", plaintext,
11304                         tdata->plaintext.len);
11305
11306         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
11307                         tdata);
11308
11309         if (retval < 0)
11310                 return retval;
11311
11312         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11313
11314         ut_params->op->sym->m_src = ut_params->ibuf;
11315
11316         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11317                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11318                         ut_params->op);
11319         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11320                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11321                                 ut_params->op, 0, 1, 0, 0);
11322         else
11323                 TEST_ASSERT_NOT_NULL(
11324                         process_crypto_request(ts_params->valid_devs[0],
11325                         ut_params->op), "failed to process sym crypto op");
11326
11327         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11328                         "crypto op processing failed");
11329
11330         return 0;
11331
11332 }
11333
11334 static int
11335 test_AES_GMAC_authentication_verify_test_case_1(void)
11336 {
11337         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
11338 }
11339
11340 static int
11341 test_AES_GMAC_authentication_verify_test_case_2(void)
11342 {
11343         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
11344 }
11345
11346 static int
11347 test_AES_GMAC_authentication_verify_test_case_3(void)
11348 {
11349         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
11350 }
11351
11352 static int
11353 test_AES_GMAC_authentication_verify_test_case_4(void)
11354 {
11355         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
11356 }
11357
11358 static int
11359 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
11360                                 uint32_t fragsz)
11361 {
11362         struct crypto_testsuite_params *ts_params = &testsuite_params;
11363         struct crypto_unittest_params *ut_params = &unittest_params;
11364         struct rte_cryptodev_info dev_info;
11365         uint64_t feature_flags;
11366         unsigned int trn_data = 0;
11367         void *digest_mem = NULL;
11368         uint32_t segs = 1;
11369         unsigned int to_trn = 0;
11370         struct rte_mbuf *buf = NULL;
11371         uint8_t *auth_tag, *plaintext;
11372         int retval;
11373
11374         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11375                               "No GMAC length in the source data");
11376
11377         /* Verify the capabilities */
11378         struct rte_cryptodev_sym_capability_idx cap_idx;
11379         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11380         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11381         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11382                         &cap_idx) == NULL)
11383                 return -ENOTSUP;
11384
11385         /* Check for any input SGL support */
11386         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11387         feature_flags = dev_info.feature_flags;
11388
11389         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
11390                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
11391                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
11392                 return -ENOTSUP;
11393
11394         if (fragsz > tdata->plaintext.len)
11395                 fragsz = tdata->plaintext.len;
11396
11397         uint16_t plaintext_len = fragsz;
11398
11399         retval = create_gmac_session(ts_params->valid_devs[0],
11400                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11401
11402         if (retval < 0)
11403                 return retval;
11404
11405         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11406         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11407                         "Failed to allocate input buffer in mempool");
11408
11409         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11410                         rte_pktmbuf_tailroom(ut_params->ibuf));
11411
11412         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11413                                 plaintext_len);
11414         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11415
11416         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11417
11418         trn_data += plaintext_len;
11419
11420         buf = ut_params->ibuf;
11421
11422         /*
11423          * Loop until no more fragments
11424          */
11425
11426         while (trn_data < tdata->plaintext.len) {
11427                 ++segs;
11428                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11429                                 (tdata->plaintext.len - trn_data) : fragsz;
11430
11431                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11432                 buf = buf->next;
11433
11434                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11435                                 rte_pktmbuf_tailroom(buf));
11436
11437                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11438                                 to_trn);
11439
11440                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11441                                 to_trn);
11442                 trn_data += to_trn;
11443                 if (trn_data  == tdata->plaintext.len)
11444                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11445                                         tdata->gmac_tag.len);
11446         }
11447         ut_params->ibuf->nb_segs = segs;
11448
11449         /*
11450          * Place digest at the end of the last buffer
11451          */
11452         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11453
11454         if (!digest_mem) {
11455                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11456                                 + tdata->gmac_tag.len);
11457                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11458                                 tdata->plaintext.len);
11459         }
11460
11461         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
11462                         tdata, digest_mem, digest_phys);
11463
11464         if (retval < 0)
11465                 return retval;
11466
11467         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11468
11469         ut_params->op->sym->m_src = ut_params->ibuf;
11470
11471         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11472                 return -ENOTSUP;
11473
11474         TEST_ASSERT_NOT_NULL(
11475                 process_crypto_request(ts_params->valid_devs[0],
11476                 ut_params->op), "failed to process sym crypto op");
11477
11478         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11479                         "crypto op processing failed");
11480
11481         auth_tag = digest_mem;
11482         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11483         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11484                         auth_tag,
11485                         tdata->gmac_tag.data,
11486                         tdata->gmac_tag.len,
11487                         "GMAC Generated auth tag not as expected");
11488
11489         return 0;
11490 }
11491
11492 /* Segment size not multiple of block size (16B) */
11493 static int
11494 test_AES_GMAC_authentication_SGL_40B(void)
11495 {
11496         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
11497 }
11498
11499 static int
11500 test_AES_GMAC_authentication_SGL_80B(void)
11501 {
11502         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
11503 }
11504
11505 static int
11506 test_AES_GMAC_authentication_SGL_2048B(void)
11507 {
11508         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
11509 }
11510
11511 /* Segment size not multiple of block size (16B) */
11512 static int
11513 test_AES_GMAC_authentication_SGL_2047B(void)
11514 {
11515         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
11516 }
11517
11518 struct test_crypto_vector {
11519         enum rte_crypto_cipher_algorithm crypto_algo;
11520         unsigned int cipher_offset;
11521         unsigned int cipher_len;
11522
11523         struct {
11524                 uint8_t data[64];
11525                 unsigned int len;
11526         } cipher_key;
11527
11528         struct {
11529                 uint8_t data[64];
11530                 unsigned int len;
11531         } iv;
11532
11533         struct {
11534                 const uint8_t *data;
11535                 unsigned int len;
11536         } plaintext;
11537
11538         struct {
11539                 const uint8_t *data;
11540                 unsigned int len;
11541         } ciphertext;
11542
11543         enum rte_crypto_auth_algorithm auth_algo;
11544         unsigned int auth_offset;
11545
11546         struct {
11547                 uint8_t data[128];
11548                 unsigned int len;
11549         } auth_key;
11550
11551         struct {
11552                 const uint8_t *data;
11553                 unsigned int len;
11554         } aad;
11555
11556         struct {
11557                 uint8_t data[128];
11558                 unsigned int len;
11559         } digest;
11560 };
11561
11562 static const struct test_crypto_vector
11563 hmac_sha1_test_crypto_vector = {
11564         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11565         .plaintext = {
11566                 .data = plaintext_hash,
11567                 .len = 512
11568         },
11569         .auth_key = {
11570                 .data = {
11571                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11572                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11573                         0xDE, 0xF4, 0xDE, 0xAD
11574                 },
11575                 .len = 20
11576         },
11577         .digest = {
11578                 .data = {
11579                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
11580                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
11581                         0x3F, 0x91, 0x64, 0x59
11582                 },
11583                 .len = 20
11584         }
11585 };
11586
11587 static const struct test_crypto_vector
11588 aes128_gmac_test_vector = {
11589         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
11590         .plaintext = {
11591                 .data = plaintext_hash,
11592                 .len = 512
11593         },
11594         .iv = {
11595                 .data = {
11596                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11597                         0x08, 0x09, 0x0A, 0x0B
11598                 },
11599                 .len = 12
11600         },
11601         .auth_key = {
11602                 .data = {
11603                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11604                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
11605                 },
11606                 .len = 16
11607         },
11608         .digest = {
11609                 .data = {
11610                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
11611                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
11612                 },
11613                 .len = 16
11614         }
11615 };
11616
11617 static const struct test_crypto_vector
11618 aes128cbc_hmac_sha1_test_vector = {
11619         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11620         .cipher_offset = 0,
11621         .cipher_len = 512,
11622         .cipher_key = {
11623                 .data = {
11624                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11625                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11626                 },
11627                 .len = 16
11628         },
11629         .iv = {
11630                 .data = {
11631                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11632                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11633                 },
11634                 .len = 16
11635         },
11636         .plaintext = {
11637                 .data = plaintext_hash,
11638                 .len = 512
11639         },
11640         .ciphertext = {
11641                 .data = ciphertext512_aes128cbc,
11642                 .len = 512
11643         },
11644         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11645         .auth_offset = 0,
11646         .auth_key = {
11647                 .data = {
11648                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11649                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11650                         0xDE, 0xF4, 0xDE, 0xAD
11651                 },
11652                 .len = 20
11653         },
11654         .digest = {
11655                 .data = {
11656                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
11657                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11658                         0x18, 0x8C, 0x1D, 0x32
11659                 },
11660                 .len = 20
11661         }
11662 };
11663
11664 static const struct test_crypto_vector
11665 aes128cbc_hmac_sha1_aad_test_vector = {
11666         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11667         .cipher_offset = 8,
11668         .cipher_len = 496,
11669         .cipher_key = {
11670                 .data = {
11671                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11672                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11673                 },
11674                 .len = 16
11675         },
11676         .iv = {
11677                 .data = {
11678                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11679                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11680                 },
11681                 .len = 16
11682         },
11683         .plaintext = {
11684                 .data = plaintext_hash,
11685                 .len = 512
11686         },
11687         .ciphertext = {
11688                 .data = ciphertext512_aes128cbc_aad,
11689                 .len = 512
11690         },
11691         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11692         .auth_offset = 0,
11693         .auth_key = {
11694                 .data = {
11695                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11696                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11697                         0xDE, 0xF4, 0xDE, 0xAD
11698                 },
11699                 .len = 20
11700         },
11701         .digest = {
11702                 .data = {
11703                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
11704                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
11705                         0x62, 0x0F, 0xFB, 0x10
11706                 },
11707                 .len = 20
11708         }
11709 };
11710
11711 static void
11712 data_corruption(uint8_t *data)
11713 {
11714         data[0] += 1;
11715 }
11716
11717 static void
11718 tag_corruption(uint8_t *data, unsigned int tag_offset)
11719 {
11720         data[tag_offset] += 1;
11721 }
11722
11723 static int
11724 create_auth_session(struct crypto_unittest_params *ut_params,
11725                 uint8_t dev_id,
11726                 const struct test_crypto_vector *reference,
11727                 enum rte_crypto_auth_operation auth_op)
11728 {
11729         struct crypto_testsuite_params *ts_params = &testsuite_params;
11730         uint8_t auth_key[reference->auth_key.len + 1];
11731
11732         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11733
11734         /* Setup Authentication Parameters */
11735         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11736         ut_params->auth_xform.auth.op = auth_op;
11737         ut_params->auth_xform.next = NULL;
11738         ut_params->auth_xform.auth.algo = reference->auth_algo;
11739         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11740         ut_params->auth_xform.auth.key.data = auth_key;
11741         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11742
11743         /* Create Crypto session*/
11744         ut_params->sess = rte_cryptodev_sym_session_create(
11745                         ts_params->session_mpool);
11746
11747         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11748                                 &ut_params->auth_xform,
11749                                 ts_params->session_priv_mpool);
11750
11751         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11752
11753         return 0;
11754 }
11755
11756 static int
11757 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
11758                 uint8_t dev_id,
11759                 const struct test_crypto_vector *reference,
11760                 enum rte_crypto_auth_operation auth_op,
11761                 enum rte_crypto_cipher_operation cipher_op)
11762 {
11763         struct crypto_testsuite_params *ts_params = &testsuite_params;
11764         uint8_t cipher_key[reference->cipher_key.len + 1];
11765         uint8_t auth_key[reference->auth_key.len + 1];
11766
11767         memcpy(cipher_key, reference->cipher_key.data,
11768                         reference->cipher_key.len);
11769         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11770
11771         /* Setup Authentication Parameters */
11772         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11773         ut_params->auth_xform.auth.op = auth_op;
11774         ut_params->auth_xform.auth.algo = reference->auth_algo;
11775         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11776         ut_params->auth_xform.auth.key.data = auth_key;
11777         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11778
11779         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
11780                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11781                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
11782         } else {
11783                 ut_params->auth_xform.next = &ut_params->cipher_xform;
11784
11785                 /* Setup Cipher Parameters */
11786                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11787                 ut_params->cipher_xform.next = NULL;
11788                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11789                 ut_params->cipher_xform.cipher.op = cipher_op;
11790                 ut_params->cipher_xform.cipher.key.data = cipher_key;
11791                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11792                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11793                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11794         }
11795
11796         /* Create Crypto session*/
11797         ut_params->sess = rte_cryptodev_sym_session_create(
11798                         ts_params->session_mpool);
11799
11800         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11801                                 &ut_params->auth_xform,
11802                                 ts_params->session_priv_mpool);
11803
11804         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11805
11806         return 0;
11807 }
11808
11809 static int
11810 create_auth_operation(struct crypto_testsuite_params *ts_params,
11811                 struct crypto_unittest_params *ut_params,
11812                 const struct test_crypto_vector *reference,
11813                 unsigned int auth_generate)
11814 {
11815         /* Generate Crypto op data structure */
11816         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11817                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11818         TEST_ASSERT_NOT_NULL(ut_params->op,
11819                         "Failed to allocate pktmbuf offload");
11820
11821         /* Set crypto operation data parameters */
11822         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11823
11824         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11825
11826         /* set crypto operation source mbuf */
11827         sym_op->m_src = ut_params->ibuf;
11828
11829         /* digest */
11830         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11831                         ut_params->ibuf, reference->digest.len);
11832
11833         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11834                         "no room to append auth tag");
11835
11836         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11837                         ut_params->ibuf, reference->plaintext.len);
11838
11839         if (auth_generate)
11840                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11841         else
11842                 memcpy(sym_op->auth.digest.data,
11843                                 reference->digest.data,
11844                                 reference->digest.len);
11845
11846         debug_hexdump(stdout, "digest:",
11847                         sym_op->auth.digest.data,
11848                         reference->digest.len);
11849
11850         sym_op->auth.data.length = reference->plaintext.len;
11851         sym_op->auth.data.offset = 0;
11852
11853         return 0;
11854 }
11855
11856 static int
11857 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
11858                 struct crypto_unittest_params *ut_params,
11859                 const struct test_crypto_vector *reference,
11860                 unsigned int auth_generate)
11861 {
11862         /* Generate Crypto op data structure */
11863         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11864                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11865         TEST_ASSERT_NOT_NULL(ut_params->op,
11866                         "Failed to allocate pktmbuf offload");
11867
11868         /* Set crypto operation data parameters */
11869         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11870
11871         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11872
11873         /* set crypto operation source mbuf */
11874         sym_op->m_src = ut_params->ibuf;
11875
11876         /* digest */
11877         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11878                         ut_params->ibuf, reference->digest.len);
11879
11880         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11881                         "no room to append auth tag");
11882
11883         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11884                         ut_params->ibuf, reference->ciphertext.len);
11885
11886         if (auth_generate)
11887                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11888         else
11889                 memcpy(sym_op->auth.digest.data,
11890                                 reference->digest.data,
11891                                 reference->digest.len);
11892
11893         debug_hexdump(stdout, "digest:",
11894                         sym_op->auth.digest.data,
11895                         reference->digest.len);
11896
11897         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11898                         reference->iv.data, reference->iv.len);
11899
11900         sym_op->cipher.data.length = 0;
11901         sym_op->cipher.data.offset = 0;
11902
11903         sym_op->auth.data.length = reference->plaintext.len;
11904         sym_op->auth.data.offset = 0;
11905
11906         return 0;
11907 }
11908
11909 static int
11910 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
11911                 struct crypto_unittest_params *ut_params,
11912                 const struct test_crypto_vector *reference,
11913                 unsigned int auth_generate)
11914 {
11915         /* Generate Crypto op data structure */
11916         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11917                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11918         TEST_ASSERT_NOT_NULL(ut_params->op,
11919                         "Failed to allocate pktmbuf offload");
11920
11921         /* Set crypto operation data parameters */
11922         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11923
11924         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11925
11926         /* set crypto operation source mbuf */
11927         sym_op->m_src = ut_params->ibuf;
11928
11929         /* digest */
11930         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11931                         ut_params->ibuf, reference->digest.len);
11932
11933         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11934                         "no room to append auth tag");
11935
11936         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11937                         ut_params->ibuf, reference->ciphertext.len);
11938
11939         if (auth_generate)
11940                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11941         else
11942                 memcpy(sym_op->auth.digest.data,
11943                                 reference->digest.data,
11944                                 reference->digest.len);
11945
11946         debug_hexdump(stdout, "digest:",
11947                         sym_op->auth.digest.data,
11948                         reference->digest.len);
11949
11950         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11951                         reference->iv.data, reference->iv.len);
11952
11953         sym_op->cipher.data.length = reference->cipher_len;
11954         sym_op->cipher.data.offset = reference->cipher_offset;
11955
11956         sym_op->auth.data.length = reference->plaintext.len;
11957         sym_op->auth.data.offset = reference->auth_offset;
11958
11959         return 0;
11960 }
11961
11962 static int
11963 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11964                 struct crypto_unittest_params *ut_params,
11965                 const struct test_crypto_vector *reference)
11966 {
11967         return create_auth_operation(ts_params, ut_params, reference, 0);
11968 }
11969
11970 static int
11971 create_auth_verify_GMAC_operation(
11972                 struct crypto_testsuite_params *ts_params,
11973                 struct crypto_unittest_params *ut_params,
11974                 const struct test_crypto_vector *reference)
11975 {
11976         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11977 }
11978
11979 static int
11980 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11981                 struct crypto_unittest_params *ut_params,
11982                 const struct test_crypto_vector *reference)
11983 {
11984         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11985 }
11986
11987 static int
11988 test_authentication_verify_fail_when_data_corruption(
11989                 struct crypto_testsuite_params *ts_params,
11990                 struct crypto_unittest_params *ut_params,
11991                 const struct test_crypto_vector *reference,
11992                 unsigned int data_corrupted)
11993 {
11994         int retval;
11995
11996         uint8_t *plaintext;
11997         struct rte_cryptodev_info dev_info;
11998
11999         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12000         uint64_t feat_flags = dev_info.feature_flags;
12001
12002         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12003                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12004                 printf("Device doesn't support RAW data-path APIs.\n");
12005                 return -ENOTSUP;
12006         }
12007
12008         /* Verify the capabilities */
12009         struct rte_cryptodev_sym_capability_idx cap_idx;
12010         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12011         cap_idx.algo.auth = reference->auth_algo;
12012         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12013                         &cap_idx) == NULL)
12014                 return -ENOTSUP;
12015
12016
12017         /* Create session */
12018         retval = create_auth_session(ut_params,
12019                         ts_params->valid_devs[0],
12020                         reference,
12021                         RTE_CRYPTO_AUTH_OP_VERIFY);
12022         if (retval < 0)
12023                 return retval;
12024
12025         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12026         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12027                         "Failed to allocate input buffer in mempool");
12028
12029         /* clear mbuf payload */
12030         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12031                         rte_pktmbuf_tailroom(ut_params->ibuf));
12032
12033         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12034                         reference->plaintext.len);
12035         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12036         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12037
12038         debug_hexdump(stdout, "plaintext:", plaintext,
12039                 reference->plaintext.len);
12040
12041         /* Create operation */
12042         retval = create_auth_verify_operation(ts_params, ut_params, reference);
12043
12044         if (retval < 0)
12045                 return retval;
12046
12047         if (data_corrupted)
12048                 data_corruption(plaintext);
12049         else
12050                 tag_corruption(plaintext, reference->plaintext.len);
12051
12052         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12053                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12054                         ut_params->op);
12055                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12056                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12057                         "authentication not failed");
12058         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12059                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12060                                 ut_params->op, 0, 1, 0, 0);
12061         else {
12062                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12063                         ut_params->op);
12064                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12065         }
12066
12067         return 0;
12068 }
12069
12070 static int
12071 test_authentication_verify_GMAC_fail_when_corruption(
12072                 struct crypto_testsuite_params *ts_params,
12073                 struct crypto_unittest_params *ut_params,
12074                 const struct test_crypto_vector *reference,
12075                 unsigned int data_corrupted)
12076 {
12077         int retval;
12078         uint8_t *plaintext;
12079         struct rte_cryptodev_info dev_info;
12080
12081         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12082         uint64_t feat_flags = dev_info.feature_flags;
12083
12084         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12085                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12086                 printf("Device doesn't support RAW data-path APIs.\n");
12087                 return -ENOTSUP;
12088         }
12089
12090         /* Verify the capabilities */
12091         struct rte_cryptodev_sym_capability_idx cap_idx;
12092         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12093         cap_idx.algo.auth = reference->auth_algo;
12094         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12095                         &cap_idx) == NULL)
12096                 return -ENOTSUP;
12097
12098         /* Create session */
12099         retval = create_auth_cipher_session(ut_params,
12100                         ts_params->valid_devs[0],
12101                         reference,
12102                         RTE_CRYPTO_AUTH_OP_VERIFY,
12103                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
12104         if (retval < 0)
12105                 return retval;
12106
12107         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12108         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12109                         "Failed to allocate input buffer in mempool");
12110
12111         /* clear mbuf payload */
12112         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12113                         rte_pktmbuf_tailroom(ut_params->ibuf));
12114
12115         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12116                         reference->plaintext.len);
12117         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12118         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12119
12120         debug_hexdump(stdout, "plaintext:", plaintext,
12121                 reference->plaintext.len);
12122
12123         /* Create operation */
12124         retval = create_auth_verify_GMAC_operation(ts_params,
12125                         ut_params,
12126                         reference);
12127
12128         if (retval < 0)
12129                 return retval;
12130
12131         if (data_corrupted)
12132                 data_corruption(plaintext);
12133         else
12134                 tag_corruption(plaintext, reference->aad.len);
12135
12136         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12137                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12138                         ut_params->op);
12139                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12140                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12141                         "authentication not failed");
12142         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12143                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12144                                 ut_params->op, 0, 1, 0, 0);
12145         else {
12146                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12147                         ut_params->op);
12148                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12149         }
12150
12151         return 0;
12152 }
12153
12154 static int
12155 test_authenticated_decryption_fail_when_corruption(
12156                 struct crypto_testsuite_params *ts_params,
12157                 struct crypto_unittest_params *ut_params,
12158                 const struct test_crypto_vector *reference,
12159                 unsigned int data_corrupted)
12160 {
12161         int retval;
12162
12163         uint8_t *ciphertext;
12164         struct rte_cryptodev_info dev_info;
12165
12166         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12167         uint64_t feat_flags = dev_info.feature_flags;
12168
12169         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12170                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12171                 printf("Device doesn't support RAW data-path APIs.\n");
12172                 return -ENOTSUP;
12173         }
12174
12175         /* Verify the capabilities */
12176         struct rte_cryptodev_sym_capability_idx cap_idx;
12177         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12178         cap_idx.algo.auth = reference->auth_algo;
12179         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12180                         &cap_idx) == NULL)
12181                 return -ENOTSUP;
12182         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12183         cap_idx.algo.cipher = reference->crypto_algo;
12184         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12185                         &cap_idx) == NULL)
12186                 return -ENOTSUP;
12187
12188         /* Create session */
12189         retval = create_auth_cipher_session(ut_params,
12190                         ts_params->valid_devs[0],
12191                         reference,
12192                         RTE_CRYPTO_AUTH_OP_VERIFY,
12193                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
12194         if (retval < 0)
12195                 return retval;
12196
12197         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12198         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12199                         "Failed to allocate input buffer in mempool");
12200
12201         /* clear mbuf payload */
12202         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12203                         rte_pktmbuf_tailroom(ut_params->ibuf));
12204
12205         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12206                         reference->ciphertext.len);
12207         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12208         memcpy(ciphertext, reference->ciphertext.data,
12209                         reference->ciphertext.len);
12210
12211         /* Create operation */
12212         retval = create_cipher_auth_verify_operation(ts_params,
12213                         ut_params,
12214                         reference);
12215
12216         if (retval < 0)
12217                 return retval;
12218
12219         if (data_corrupted)
12220                 data_corruption(ciphertext);
12221         else
12222                 tag_corruption(ciphertext, reference->ciphertext.len);
12223
12224         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
12225                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12226                         ut_params->op);
12227                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
12228                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12229                         "authentication not failed");
12230         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12231                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12232                                 ut_params->op, 1, 1, 0, 0);
12233         else {
12234                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12235                         ut_params->op);
12236                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
12237         }
12238
12239         return 0;
12240 }
12241
12242 static int
12243 test_authenticated_encryt_with_esn(
12244                 struct crypto_testsuite_params *ts_params,
12245                 struct crypto_unittest_params *ut_params,
12246                 const struct test_crypto_vector *reference)
12247 {
12248         int retval;
12249
12250         uint8_t *authciphertext, *plaintext, *auth_tag;
12251         uint16_t plaintext_pad_len;
12252         uint8_t cipher_key[reference->cipher_key.len + 1];
12253         uint8_t auth_key[reference->auth_key.len + 1];
12254         struct rte_cryptodev_info dev_info;
12255
12256         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12257         uint64_t feat_flags = dev_info.feature_flags;
12258
12259         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12260                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12261                 printf("Device doesn't support RAW data-path APIs.\n");
12262                 return -ENOTSUP;
12263         }
12264
12265         /* Verify the capabilities */
12266         struct rte_cryptodev_sym_capability_idx cap_idx;
12267         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12268         cap_idx.algo.auth = reference->auth_algo;
12269         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12270                         &cap_idx) == NULL)
12271                 return -ENOTSUP;
12272         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12273         cap_idx.algo.cipher = reference->crypto_algo;
12274         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12275                         &cap_idx) == NULL)
12276                 return -ENOTSUP;
12277
12278         /* Create session */
12279         memcpy(cipher_key, reference->cipher_key.data,
12280                         reference->cipher_key.len);
12281         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12282
12283         /* Setup Cipher Parameters */
12284         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12285         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12286         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12287         ut_params->cipher_xform.cipher.key.data = cipher_key;
12288         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12289         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12290         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12291
12292         ut_params->cipher_xform.next = &ut_params->auth_xform;
12293
12294         /* Setup Authentication Parameters */
12295         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12296         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12297         ut_params->auth_xform.auth.algo = reference->auth_algo;
12298         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12299         ut_params->auth_xform.auth.key.data = auth_key;
12300         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12301         ut_params->auth_xform.next = NULL;
12302
12303         /* Create Crypto session*/
12304         ut_params->sess = rte_cryptodev_sym_session_create(
12305                         ts_params->session_mpool);
12306
12307         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12308                                 ut_params->sess,
12309                                 &ut_params->cipher_xform,
12310                                 ts_params->session_priv_mpool);
12311
12312         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12313
12314         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12315         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12316                         "Failed to allocate input buffer in mempool");
12317
12318         /* clear mbuf payload */
12319         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12320                         rte_pktmbuf_tailroom(ut_params->ibuf));
12321
12322         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12323                         reference->plaintext.len);
12324         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12325         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12326
12327         /* Create operation */
12328         retval = create_cipher_auth_operation(ts_params,
12329                         ut_params,
12330                         reference, 0);
12331
12332         if (retval < 0)
12333                 return retval;
12334
12335         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12336                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12337                         ut_params->op);
12338         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12339                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12340                                 ut_params->op, 1, 1, 0, 0);
12341         else
12342                 ut_params->op = process_crypto_request(
12343                         ts_params->valid_devs[0], ut_params->op);
12344
12345         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
12346
12347         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12348                         "crypto op processing failed");
12349
12350         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
12351
12352         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
12353                         ut_params->op->sym->auth.data.offset);
12354         auth_tag = authciphertext + plaintext_pad_len;
12355         debug_hexdump(stdout, "ciphertext:", authciphertext,
12356                         reference->ciphertext.len);
12357         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
12358
12359         /* Validate obuf */
12360         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12361                         authciphertext,
12362                         reference->ciphertext.data,
12363                         reference->ciphertext.len,
12364                         "Ciphertext data not as expected");
12365
12366         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12367                         auth_tag,
12368                         reference->digest.data,
12369                         reference->digest.len,
12370                         "Generated digest not as expected");
12371
12372         return TEST_SUCCESS;
12373
12374 }
12375
12376 static int
12377 test_authenticated_decrypt_with_esn(
12378                 struct crypto_testsuite_params *ts_params,
12379                 struct crypto_unittest_params *ut_params,
12380                 const struct test_crypto_vector *reference)
12381 {
12382         int retval;
12383
12384         uint8_t *ciphertext;
12385         uint8_t cipher_key[reference->cipher_key.len + 1];
12386         uint8_t auth_key[reference->auth_key.len + 1];
12387         struct rte_cryptodev_info dev_info;
12388
12389         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12390         uint64_t feat_flags = dev_info.feature_flags;
12391
12392         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12393                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12394                 printf("Device doesn't support RAW data-path APIs.\n");
12395                 return -ENOTSUP;
12396         }
12397
12398         /* Verify the capabilities */
12399         struct rte_cryptodev_sym_capability_idx cap_idx;
12400         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12401         cap_idx.algo.auth = reference->auth_algo;
12402         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12403                         &cap_idx) == NULL)
12404                 return -ENOTSUP;
12405         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12406         cap_idx.algo.cipher = reference->crypto_algo;
12407         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12408                         &cap_idx) == NULL)
12409                 return -ENOTSUP;
12410
12411         /* Create session */
12412         memcpy(cipher_key, reference->cipher_key.data,
12413                         reference->cipher_key.len);
12414         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12415
12416         /* Setup Authentication Parameters */
12417         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12418         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
12419         ut_params->auth_xform.auth.algo = reference->auth_algo;
12420         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12421         ut_params->auth_xform.auth.key.data = auth_key;
12422         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12423         ut_params->auth_xform.next = &ut_params->cipher_xform;
12424
12425         /* Setup Cipher Parameters */
12426         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12427         ut_params->cipher_xform.next = NULL;
12428         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12429         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
12430         ut_params->cipher_xform.cipher.key.data = cipher_key;
12431         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12432         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12433         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12434
12435         /* Create Crypto session*/
12436         ut_params->sess = rte_cryptodev_sym_session_create(
12437                         ts_params->session_mpool);
12438
12439         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12440                                 ut_params->sess,
12441                                 &ut_params->auth_xform,
12442                                 ts_params->session_priv_mpool);
12443
12444         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12445
12446         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12447         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12448                         "Failed to allocate input buffer in mempool");
12449
12450         /* clear mbuf payload */
12451         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12452                         rte_pktmbuf_tailroom(ut_params->ibuf));
12453
12454         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12455                         reference->ciphertext.len);
12456         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12457         memcpy(ciphertext, reference->ciphertext.data,
12458                         reference->ciphertext.len);
12459
12460         /* Create operation */
12461         retval = create_cipher_auth_verify_operation(ts_params,
12462                         ut_params,
12463                         reference);
12464
12465         if (retval < 0)
12466                 return retval;
12467
12468         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12469                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12470                         ut_params->op);
12471         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12472                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12473                                 ut_params->op, 1, 1, 0, 0);
12474         else
12475                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12476                         ut_params->op);
12477
12478         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
12479         TEST_ASSERT_EQUAL(ut_params->op->status,
12480                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12481                         "crypto op processing passed");
12482
12483         ut_params->obuf = ut_params->op->sym->m_src;
12484         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
12485
12486         return 0;
12487 }
12488
12489 static int
12490 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
12491                 const struct aead_test_data *tdata,
12492                 void *digest_mem, uint64_t digest_phys)
12493 {
12494         struct crypto_testsuite_params *ts_params = &testsuite_params;
12495         struct crypto_unittest_params *ut_params = &unittest_params;
12496
12497         const unsigned int auth_tag_len = tdata->auth_tag.len;
12498         const unsigned int iv_len = tdata->iv.len;
12499         unsigned int aad_len = tdata->aad.len;
12500         unsigned int aad_len_pad = 0;
12501
12502         /* Generate Crypto op data structure */
12503         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12504                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12505         TEST_ASSERT_NOT_NULL(ut_params->op,
12506                 "Failed to allocate symmetric crypto operation struct");
12507
12508         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12509
12510         sym_op->aead.digest.data = digest_mem;
12511
12512         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
12513                         "no room to append digest");
12514
12515         sym_op->aead.digest.phys_addr = digest_phys;
12516
12517         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
12518                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
12519                                 auth_tag_len);
12520                 debug_hexdump(stdout, "digest:",
12521                                 sym_op->aead.digest.data,
12522                                 auth_tag_len);
12523         }
12524
12525         /* Append aad data */
12526         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
12527                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12528                                 uint8_t *, IV_OFFSET);
12529
12530                 /* Copy IV 1 byte after the IV pointer, according to the API */
12531                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
12532
12533                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
12534
12535                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12536                                 ut_params->ibuf, aad_len);
12537                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12538                                 "no room to prepend aad");
12539                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12540                                 ut_params->ibuf);
12541
12542                 memset(sym_op->aead.aad.data, 0, aad_len);
12543                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
12544                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12545
12546                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12547                 debug_hexdump(stdout, "aad:",
12548                                 sym_op->aead.aad.data, aad_len);
12549         } else {
12550                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12551                                 uint8_t *, IV_OFFSET);
12552
12553                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
12554
12555                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
12556
12557                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12558                                 ut_params->ibuf, aad_len_pad);
12559                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12560                                 "no room to prepend aad");
12561                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12562                                 ut_params->ibuf);
12563
12564                 memset(sym_op->aead.aad.data, 0, aad_len);
12565                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12566
12567                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12568                 debug_hexdump(stdout, "aad:",
12569                                 sym_op->aead.aad.data, aad_len);
12570         }
12571
12572         sym_op->aead.data.length = tdata->plaintext.len;
12573         sym_op->aead.data.offset = aad_len_pad;
12574
12575         return 0;
12576 }
12577
12578 #define SGL_MAX_NO      16
12579
12580 static int
12581 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
12582                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
12583 {
12584         struct crypto_testsuite_params *ts_params = &testsuite_params;
12585         struct crypto_unittest_params *ut_params = &unittest_params;
12586         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
12587         int retval;
12588         int to_trn = 0;
12589         int to_trn_tbl[SGL_MAX_NO];
12590         int segs = 1;
12591         unsigned int trn_data = 0;
12592         uint8_t *plaintext, *ciphertext, *auth_tag;
12593         struct rte_cryptodev_info dev_info;
12594
12595         /* Verify the capabilities */
12596         struct rte_cryptodev_sym_capability_idx cap_idx;
12597         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
12598         cap_idx.algo.aead = tdata->algo;
12599         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12600                         &cap_idx) == NULL)
12601                 return -ENOTSUP;
12602
12603         /* OOP not supported with CPU crypto */
12604         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12605                 return -ENOTSUP;
12606
12607         /* Detailed check for the particular SGL support flag */
12608         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12609         if (!oop) {
12610                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12611                 if (sgl_in && (!(dev_info.feature_flags &
12612                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
12613                         return -ENOTSUP;
12614
12615                 uint64_t feat_flags = dev_info.feature_flags;
12616
12617                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12618                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12619                         printf("Device doesn't support RAW data-path APIs.\n");
12620                         return -ENOTSUP;
12621                 }
12622         } else {
12623                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12624                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
12625                                 tdata->plaintext.len;
12626                 /* Raw data path API does not support OOP */
12627                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12628                         return -ENOTSUP;
12629                 if (sgl_in && !sgl_out) {
12630                         if (!(dev_info.feature_flags &
12631                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
12632                                 return -ENOTSUP;
12633                 } else if (!sgl_in && sgl_out) {
12634                         if (!(dev_info.feature_flags &
12635                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
12636                                 return -ENOTSUP;
12637                 } else if (sgl_in && sgl_out) {
12638                         if (!(dev_info.feature_flags &
12639                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
12640                                 return -ENOTSUP;
12641                 }
12642         }
12643
12644         if (fragsz > tdata->plaintext.len)
12645                 fragsz = tdata->plaintext.len;
12646
12647         uint16_t plaintext_len = fragsz;
12648         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
12649
12650         if (fragsz_oop > tdata->plaintext.len)
12651                 frag_size_oop = tdata->plaintext.len;
12652
12653         int ecx = 0;
12654         void *digest_mem = NULL;
12655
12656         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
12657
12658         if (tdata->plaintext.len % fragsz != 0) {
12659                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
12660                         return 1;
12661         }       else {
12662                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
12663                         return 1;
12664         }
12665
12666         /*
12667          * For out-op-place we need to alloc another mbuf
12668          */
12669         if (oop) {
12670                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12671                 rte_pktmbuf_append(ut_params->obuf,
12672                                 frag_size_oop + prepend_len);
12673                 buf_oop = ut_params->obuf;
12674         }
12675
12676         /* Create AEAD session */
12677         retval = create_aead_session(ts_params->valid_devs[0],
12678                         tdata->algo,
12679                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
12680                         tdata->key.data, tdata->key.len,
12681                         tdata->aad.len, tdata->auth_tag.len,
12682                         tdata->iv.len);
12683         if (retval < 0)
12684                 return retval;
12685
12686         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12687
12688         /* clear mbuf payload */
12689         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12690                         rte_pktmbuf_tailroom(ut_params->ibuf));
12691
12692         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12693                         plaintext_len);
12694
12695         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12696
12697         trn_data += plaintext_len;
12698
12699         buf = ut_params->ibuf;
12700
12701         /*
12702          * Loop until no more fragments
12703          */
12704
12705         while (trn_data < tdata->plaintext.len) {
12706                 ++segs;
12707                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12708                                 (tdata->plaintext.len - trn_data) : fragsz;
12709
12710                 to_trn_tbl[ecx++] = to_trn;
12711
12712                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12713                 buf = buf->next;
12714
12715                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12716                                 rte_pktmbuf_tailroom(buf));
12717
12718                 /* OOP */
12719                 if (oop && !fragsz_oop) {
12720                         buf_last_oop = buf_oop->next =
12721                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12722                         buf_oop = buf_oop->next;
12723                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12724                                         0, rte_pktmbuf_tailroom(buf_oop));
12725                         rte_pktmbuf_append(buf_oop, to_trn);
12726                 }
12727
12728                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12729                                 to_trn);
12730
12731                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12732                                 to_trn);
12733                 trn_data += to_trn;
12734                 if (trn_data  == tdata->plaintext.len) {
12735                         if (oop) {
12736                                 if (!fragsz_oop)
12737                                         digest_mem = rte_pktmbuf_append(buf_oop,
12738                                                 tdata->auth_tag.len);
12739                         } else
12740                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12741                                         tdata->auth_tag.len);
12742                 }
12743         }
12744
12745         uint64_t digest_phys = 0;
12746
12747         ut_params->ibuf->nb_segs = segs;
12748
12749         segs = 1;
12750         if (fragsz_oop && oop) {
12751                 to_trn = 0;
12752                 ecx = 0;
12753
12754                 if (frag_size_oop == tdata->plaintext.len) {
12755                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
12756                                 tdata->auth_tag.len);
12757
12758                         digest_phys = rte_pktmbuf_iova_offset(
12759                                         ut_params->obuf,
12760                                         tdata->plaintext.len + prepend_len);
12761                 }
12762
12763                 trn_data = frag_size_oop;
12764                 while (trn_data < tdata->plaintext.len) {
12765                         ++segs;
12766                         to_trn =
12767                                 (tdata->plaintext.len - trn_data <
12768                                                 frag_size_oop) ?
12769                                 (tdata->plaintext.len - trn_data) :
12770                                                 frag_size_oop;
12771
12772                         to_trn_tbl[ecx++] = to_trn;
12773
12774                         buf_last_oop = buf_oop->next =
12775                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12776                         buf_oop = buf_oop->next;
12777                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12778                                         0, rte_pktmbuf_tailroom(buf_oop));
12779                         rte_pktmbuf_append(buf_oop, to_trn);
12780
12781                         trn_data += to_trn;
12782
12783                         if (trn_data  == tdata->plaintext.len) {
12784                                 digest_mem = rte_pktmbuf_append(buf_oop,
12785                                         tdata->auth_tag.len);
12786                         }
12787                 }
12788
12789                 ut_params->obuf->nb_segs = segs;
12790         }
12791
12792         /*
12793          * Place digest at the end of the last buffer
12794          */
12795         if (!digest_phys)
12796                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12797         if (oop && buf_last_oop)
12798                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
12799
12800         if (!digest_mem && !oop) {
12801                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12802                                 + tdata->auth_tag.len);
12803                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12804                                 tdata->plaintext.len);
12805         }
12806
12807         /* Create AEAD operation */
12808         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
12809                         tdata, digest_mem, digest_phys);
12810
12811         if (retval < 0)
12812                 return retval;
12813
12814         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12815
12816         ut_params->op->sym->m_src = ut_params->ibuf;
12817         if (oop)
12818                 ut_params->op->sym->m_dst = ut_params->obuf;
12819
12820         /* Process crypto operation */
12821         if (oop == IN_PLACE &&
12822                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12823                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
12824         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12825                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12826                                 ut_params->op, 0, 0, 0, 0);
12827         else
12828                 TEST_ASSERT_NOT_NULL(
12829                         process_crypto_request(ts_params->valid_devs[0],
12830                         ut_params->op), "failed to process sym crypto op");
12831
12832         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12833                         "crypto op processing failed");
12834
12835
12836         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
12837                         uint8_t *, prepend_len);
12838         if (oop) {
12839                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12840                                 uint8_t *, prepend_len);
12841         }
12842
12843         if (fragsz_oop)
12844                 fragsz = fragsz_oop;
12845
12846         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12847                         ciphertext,
12848                         tdata->ciphertext.data,
12849                         fragsz,
12850                         "Ciphertext data not as expected");
12851
12852         buf = ut_params->op->sym->m_src->next;
12853         if (oop)
12854                 buf = ut_params->op->sym->m_dst->next;
12855
12856         unsigned int off = fragsz;
12857
12858         ecx = 0;
12859         while (buf) {
12860                 ciphertext = rte_pktmbuf_mtod(buf,
12861                                 uint8_t *);
12862
12863                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12864                                 ciphertext,
12865                                 tdata->ciphertext.data + off,
12866                                 to_trn_tbl[ecx],
12867                                 "Ciphertext data not as expected");
12868
12869                 off += to_trn_tbl[ecx++];
12870                 buf = buf->next;
12871         }
12872
12873         auth_tag = digest_mem;
12874         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12875                         auth_tag,
12876                         tdata->auth_tag.data,
12877                         tdata->auth_tag.len,
12878                         "Generated auth tag not as expected");
12879
12880         return 0;
12881 }
12882
12883 static int
12884 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
12885 {
12886         return test_authenticated_encryption_SGL(
12887                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
12888 }
12889
12890 static int
12891 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
12892 {
12893         return test_authenticated_encryption_SGL(
12894                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
12895 }
12896
12897 static int
12898 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
12899 {
12900         return test_authenticated_encryption_SGL(
12901                         &gcm_test_case_8, OUT_OF_PLACE, 400,
12902                         gcm_test_case_8.plaintext.len);
12903 }
12904
12905 static int
12906 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
12907 {
12908         /* This test is not for OPENSSL PMD */
12909         if (gbl_driver_id == rte_cryptodev_driver_id_get(
12910                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
12911                 return -ENOTSUP;
12912
12913         return test_authenticated_encryption_SGL(
12914                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
12915 }
12916
12917 static int
12918 test_authentication_verify_fail_when_data_corrupted(
12919                 struct crypto_testsuite_params *ts_params,
12920                 struct crypto_unittest_params *ut_params,
12921                 const struct test_crypto_vector *reference)
12922 {
12923         return test_authentication_verify_fail_when_data_corruption(
12924                         ts_params, ut_params, reference, 1);
12925 }
12926
12927 static int
12928 test_authentication_verify_fail_when_tag_corrupted(
12929                 struct crypto_testsuite_params *ts_params,
12930                 struct crypto_unittest_params *ut_params,
12931                 const struct test_crypto_vector *reference)
12932 {
12933         return test_authentication_verify_fail_when_data_corruption(
12934                         ts_params, ut_params, reference, 0);
12935 }
12936
12937 static int
12938 test_authentication_verify_GMAC_fail_when_data_corrupted(
12939                 struct crypto_testsuite_params *ts_params,
12940                 struct crypto_unittest_params *ut_params,
12941                 const struct test_crypto_vector *reference)
12942 {
12943         return test_authentication_verify_GMAC_fail_when_corruption(
12944                         ts_params, ut_params, reference, 1);
12945 }
12946
12947 static int
12948 test_authentication_verify_GMAC_fail_when_tag_corrupted(
12949                 struct crypto_testsuite_params *ts_params,
12950                 struct crypto_unittest_params *ut_params,
12951                 const struct test_crypto_vector *reference)
12952 {
12953         return test_authentication_verify_GMAC_fail_when_corruption(
12954                         ts_params, ut_params, reference, 0);
12955 }
12956
12957 static int
12958 test_authenticated_decryption_fail_when_data_corrupted(
12959                 struct crypto_testsuite_params *ts_params,
12960                 struct crypto_unittest_params *ut_params,
12961                 const struct test_crypto_vector *reference)
12962 {
12963         return test_authenticated_decryption_fail_when_corruption(
12964                         ts_params, ut_params, reference, 1);
12965 }
12966
12967 static int
12968 test_authenticated_decryption_fail_when_tag_corrupted(
12969                 struct crypto_testsuite_params *ts_params,
12970                 struct crypto_unittest_params *ut_params,
12971                 const struct test_crypto_vector *reference)
12972 {
12973         return test_authenticated_decryption_fail_when_corruption(
12974                         ts_params, ut_params, reference, 0);
12975 }
12976
12977 static int
12978 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
12979 {
12980         return test_authentication_verify_fail_when_data_corrupted(
12981                         &testsuite_params, &unittest_params,
12982                         &hmac_sha1_test_crypto_vector);
12983 }
12984
12985 static int
12986 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
12987 {
12988         return test_authentication_verify_fail_when_tag_corrupted(
12989                         &testsuite_params, &unittest_params,
12990                         &hmac_sha1_test_crypto_vector);
12991 }
12992
12993 static int
12994 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
12995 {
12996         return test_authentication_verify_GMAC_fail_when_data_corrupted(
12997                         &testsuite_params, &unittest_params,
12998                         &aes128_gmac_test_vector);
12999 }
13000
13001 static int
13002 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
13003 {
13004         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
13005                         &testsuite_params, &unittest_params,
13006                         &aes128_gmac_test_vector);
13007 }
13008
13009 static int
13010 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
13011 {
13012         return test_authenticated_decryption_fail_when_data_corrupted(
13013                         &testsuite_params,
13014                         &unittest_params,
13015                         &aes128cbc_hmac_sha1_test_vector);
13016 }
13017
13018 static int
13019 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
13020 {
13021         return test_authenticated_decryption_fail_when_tag_corrupted(
13022                         &testsuite_params,
13023                         &unittest_params,
13024                         &aes128cbc_hmac_sha1_test_vector);
13025 }
13026
13027 static int
13028 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13029 {
13030         return test_authenticated_encryt_with_esn(
13031                         &testsuite_params,
13032                         &unittest_params,
13033                         &aes128cbc_hmac_sha1_aad_test_vector);
13034 }
13035
13036 static int
13037 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
13038 {
13039         return test_authenticated_decrypt_with_esn(
13040                         &testsuite_params,
13041                         &unittest_params,
13042                         &aes128cbc_hmac_sha1_aad_test_vector);
13043 }
13044
13045 static int
13046 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
13047 {
13048         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
13049 }
13050
13051 static int
13052 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
13053 {
13054         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
13055 }
13056
13057 #ifdef RTE_CRYPTO_SCHEDULER
13058
13059 /* global AESNI worker IDs for the scheduler test */
13060 uint8_t aesni_ids[2];
13061
13062 static int
13063 test_scheduler_attach_slave_op(void)
13064 {
13065         struct crypto_testsuite_params *ts_params = &testsuite_params;
13066         uint8_t sched_id = ts_params->valid_devs[0];
13067         uint32_t nb_devs, i, nb_devs_attached = 0;
13068         int ret;
13069         char vdev_name[32];
13070
13071         /* create 2 AESNI_MB if necessary */
13072         nb_devs = rte_cryptodev_device_count_by_driver(
13073                         rte_cryptodev_driver_id_get(
13074                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
13075         if (nb_devs < 2) {
13076                 for (i = nb_devs; i < 2; i++) {
13077                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
13078                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
13079                                         i);
13080                         ret = rte_vdev_init(vdev_name, NULL);
13081
13082                         TEST_ASSERT(ret == 0,
13083                                 "Failed to create instance %u of"
13084                                 " pmd : %s",
13085                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13086                 }
13087         }
13088
13089         /* attach 2 AESNI_MB cdevs */
13090         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
13091                         i++) {
13092                 struct rte_cryptodev_info info;
13093                 unsigned int session_size;
13094
13095                 rte_cryptodev_info_get(i, &info);
13096                 if (info.driver_id != rte_cryptodev_driver_id_get(
13097                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
13098                         continue;
13099
13100                 session_size = rte_cryptodev_sym_get_private_session_size(i);
13101                 /*
13102                  * Create the session mempool again, since now there are new devices
13103                  * to use the mempool.
13104                  */
13105                 if (ts_params->session_mpool) {
13106                         rte_mempool_free(ts_params->session_mpool);
13107                         ts_params->session_mpool = NULL;
13108                 }
13109                 if (ts_params->session_priv_mpool) {
13110                         rte_mempool_free(ts_params->session_priv_mpool);
13111                         ts_params->session_priv_mpool = NULL;
13112                 }
13113
13114                 if (info.sym.max_nb_sessions != 0 &&
13115                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
13116                         RTE_LOG(ERR, USER1,
13117                                         "Device does not support "
13118                                         "at least %u sessions\n",
13119                                         MAX_NB_SESSIONS);
13120                         return TEST_FAILED;
13121                 }
13122                 /*
13123                  * Create mempool with maximum number of sessions,
13124                  * to include the session headers
13125                  */
13126                 if (ts_params->session_mpool == NULL) {
13127                         ts_params->session_mpool =
13128                                 rte_cryptodev_sym_session_pool_create(
13129                                                 "test_sess_mp",
13130                                                 MAX_NB_SESSIONS, 0, 0, 0,
13131                                                 SOCKET_ID_ANY);
13132                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
13133                                         "session mempool allocation failed");
13134                 }
13135
13136                 /*
13137                  * Create mempool with maximum number of sessions,
13138                  * to include device specific session private data
13139                  */
13140                 if (ts_params->session_priv_mpool == NULL) {
13141                         ts_params->session_priv_mpool = rte_mempool_create(
13142                                         "test_sess_mp_priv",
13143                                         MAX_NB_SESSIONS,
13144                                         session_size,
13145                                         0, 0, NULL, NULL, NULL,
13146                                         NULL, SOCKET_ID_ANY,
13147                                         0);
13148
13149                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
13150                                         "session mempool allocation failed");
13151                 }
13152
13153                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
13154                 ts_params->qp_conf.mp_session_private =
13155                                 ts_params->session_priv_mpool;
13156
13157                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
13158                                 (uint8_t)i);
13159
13160                 TEST_ASSERT(ret == 0,
13161                         "Failed to attach device %u of pmd : %s", i,
13162                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13163
13164                 aesni_ids[nb_devs_attached] = (uint8_t)i;
13165
13166                 nb_devs_attached++;
13167         }
13168
13169         return 0;
13170 }
13171
13172 static int
13173 test_scheduler_detach_slave_op(void)
13174 {
13175         struct crypto_testsuite_params *ts_params = &testsuite_params;
13176         uint8_t sched_id = ts_params->valid_devs[0];
13177         uint32_t i;
13178         int ret;
13179
13180         for (i = 0; i < 2; i++) {
13181                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
13182                                 aesni_ids[i]);
13183                 TEST_ASSERT(ret == 0,
13184                         "Failed to detach device %u", aesni_ids[i]);
13185         }
13186
13187         return 0;
13188 }
13189
13190 static int
13191 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
13192 {
13193         struct crypto_testsuite_params *ts_params = &testsuite_params;
13194         uint8_t sched_id = ts_params->valid_devs[0];
13195         /* set mode */
13196         return rte_cryptodev_scheduler_mode_set(sched_id,
13197                 scheduler_mode);
13198 }
13199
13200 static int
13201 test_scheduler_mode_roundrobin_op(void)
13202 {
13203         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
13204                         0, "Failed to set roundrobin mode");
13205         return 0;
13206
13207 }
13208
13209 static int
13210 test_scheduler_mode_multicore_op(void)
13211 {
13212         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
13213                         0, "Failed to set multicore mode");
13214
13215         return 0;
13216 }
13217
13218 static int
13219 test_scheduler_mode_failover_op(void)
13220 {
13221         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
13222                         0, "Failed to set failover mode");
13223
13224         return 0;
13225 }
13226
13227 static int
13228 test_scheduler_mode_pkt_size_distr_op(void)
13229 {
13230         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
13231                         0, "Failed to set pktsize mode");
13232
13233         return 0;
13234 }
13235
13236 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
13237         .suite_name = "Crypto Device Scheduler Unit Test Suite",
13238         .setup = testsuite_setup,
13239         .teardown = testsuite_teardown,
13240         .unit_test_cases = {
13241                 /* Multi Core */
13242                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13243                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
13244                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13245                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13246                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13247                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13248
13249                 /* Round Robin */
13250                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13251                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
13252                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13253                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13254                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13255                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13256
13257                 /* Fail over */
13258                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13259                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
13260                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13261                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13262                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13263                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13264
13265                 /* PKT SIZE */
13266                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13267                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
13268                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13269                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13270                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13271                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13272
13273                 TEST_CASES_END() /**< NULL terminate unit test array */
13274         }
13275 };
13276
13277 #endif /* RTE_CRYPTO_SCHEDULER */
13278
13279 static struct unit_test_suite cryptodev_testsuite  = {
13280         .suite_name = "Crypto Unit Test Suite",
13281         .setup = testsuite_setup,
13282         .teardown = testsuite_teardown,
13283         .unit_test_cases = {
13284                 TEST_CASE_ST(ut_setup, ut_teardown,
13285                                 test_device_configure_invalid_dev_id),
13286                 TEST_CASE_ST(ut_setup, ut_teardown,
13287                                 test_queue_pair_descriptor_setup),
13288                 TEST_CASE_ST(ut_setup, ut_teardown,
13289                                 test_device_configure_invalid_queue_pair_ids),
13290                 TEST_CASE_ST(ut_setup, ut_teardown,
13291                                 test_multi_session),
13292                 TEST_CASE_ST(ut_setup, ut_teardown,
13293                                 test_multi_session_random_usage),
13294
13295                 TEST_CASE_ST(ut_setup, ut_teardown,
13296                         test_null_invalid_operation),
13297                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
13298                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13299                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13300                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13301                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13302                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
13303                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
13304                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
13305                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13306                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
13307
13308                 /** AES CCM Authenticated Encryption 128 bits key */
13309                 TEST_CASE_ST(ut_setup, ut_teardown,
13310                         test_AES_CCM_authenticated_encryption_test_case_128_1),
13311                 TEST_CASE_ST(ut_setup, ut_teardown,
13312                         test_AES_CCM_authenticated_encryption_test_case_128_2),
13313                 TEST_CASE_ST(ut_setup, ut_teardown,
13314                         test_AES_CCM_authenticated_encryption_test_case_128_3),
13315
13316                 /** AES CCM Authenticated Decryption 128 bits key*/
13317                 TEST_CASE_ST(ut_setup, ut_teardown,
13318                         test_AES_CCM_authenticated_decryption_test_case_128_1),
13319                 TEST_CASE_ST(ut_setup, ut_teardown,
13320                         test_AES_CCM_authenticated_decryption_test_case_128_2),
13321                 TEST_CASE_ST(ut_setup, ut_teardown,
13322                         test_AES_CCM_authenticated_decryption_test_case_128_3),
13323
13324                 /** AES CCM Authenticated Encryption 192 bits key */
13325                 TEST_CASE_ST(ut_setup, ut_teardown,
13326                         test_AES_CCM_authenticated_encryption_test_case_192_1),
13327                 TEST_CASE_ST(ut_setup, ut_teardown,
13328                         test_AES_CCM_authenticated_encryption_test_case_192_2),
13329                 TEST_CASE_ST(ut_setup, ut_teardown,
13330                         test_AES_CCM_authenticated_encryption_test_case_192_3),
13331
13332                 /** AES CCM Authenticated Decryption 192 bits key*/
13333                 TEST_CASE_ST(ut_setup, ut_teardown,
13334                         test_AES_CCM_authenticated_decryption_test_case_192_1),
13335                 TEST_CASE_ST(ut_setup, ut_teardown,
13336                         test_AES_CCM_authenticated_decryption_test_case_192_2),
13337                 TEST_CASE_ST(ut_setup, ut_teardown,
13338                         test_AES_CCM_authenticated_decryption_test_case_192_3),
13339
13340                 /** AES CCM Authenticated Encryption 256 bits key */
13341                 TEST_CASE_ST(ut_setup, ut_teardown,
13342                         test_AES_CCM_authenticated_encryption_test_case_256_1),
13343                 TEST_CASE_ST(ut_setup, ut_teardown,
13344                         test_AES_CCM_authenticated_encryption_test_case_256_2),
13345                 TEST_CASE_ST(ut_setup, ut_teardown,
13346                         test_AES_CCM_authenticated_encryption_test_case_256_3),
13347
13348                 /** AES CCM Authenticated Decryption 256 bits key*/
13349                 TEST_CASE_ST(ut_setup, ut_teardown,
13350                         test_AES_CCM_authenticated_decryption_test_case_256_1),
13351                 TEST_CASE_ST(ut_setup, ut_teardown,
13352                         test_AES_CCM_authenticated_decryption_test_case_256_2),
13353                 TEST_CASE_ST(ut_setup, ut_teardown,
13354                         test_AES_CCM_authenticated_decryption_test_case_256_3),
13355
13356                 /** AES GCM Authenticated Encryption */
13357                 TEST_CASE_ST(ut_setup, ut_teardown,
13358                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13359                 TEST_CASE_ST(ut_setup, ut_teardown,
13360                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13361                 TEST_CASE_ST(ut_setup, ut_teardown,
13362                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13363                 TEST_CASE_ST(ut_setup, ut_teardown,
13364                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13365                 TEST_CASE_ST(ut_setup, ut_teardown,
13366                         test_AES_GCM_authenticated_encryption_test_case_1),
13367                 TEST_CASE_ST(ut_setup, ut_teardown,
13368                         test_AES_GCM_authenticated_encryption_test_case_2),
13369                 TEST_CASE_ST(ut_setup, ut_teardown,
13370                         test_AES_GCM_authenticated_encryption_test_case_3),
13371                 TEST_CASE_ST(ut_setup, ut_teardown,
13372                         test_AES_GCM_authenticated_encryption_test_case_4),
13373                 TEST_CASE_ST(ut_setup, ut_teardown,
13374                         test_AES_GCM_authenticated_encryption_test_case_5),
13375                 TEST_CASE_ST(ut_setup, ut_teardown,
13376                         test_AES_GCM_authenticated_encryption_test_case_6),
13377                 TEST_CASE_ST(ut_setup, ut_teardown,
13378                         test_AES_GCM_authenticated_encryption_test_case_7),
13379                 TEST_CASE_ST(ut_setup, ut_teardown,
13380                         test_AES_GCM_authenticated_encryption_test_case_8),
13381                 TEST_CASE_ST(ut_setup, ut_teardown,
13382                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
13383
13384                 /** AES GCM Authenticated Decryption */
13385                 TEST_CASE_ST(ut_setup, ut_teardown,
13386                         test_AES_GCM_authenticated_decryption_test_case_1),
13387                 TEST_CASE_ST(ut_setup, ut_teardown,
13388                         test_AES_GCM_authenticated_decryption_test_case_2),
13389                 TEST_CASE_ST(ut_setup, ut_teardown,
13390                         test_AES_GCM_authenticated_decryption_test_case_3),
13391                 TEST_CASE_ST(ut_setup, ut_teardown,
13392                         test_AES_GCM_authenticated_decryption_test_case_4),
13393                 TEST_CASE_ST(ut_setup, ut_teardown,
13394                         test_AES_GCM_authenticated_decryption_test_case_5),
13395                 TEST_CASE_ST(ut_setup, ut_teardown,
13396                         test_AES_GCM_authenticated_decryption_test_case_6),
13397                 TEST_CASE_ST(ut_setup, ut_teardown,
13398                         test_AES_GCM_authenticated_decryption_test_case_7),
13399                 TEST_CASE_ST(ut_setup, ut_teardown,
13400                         test_AES_GCM_authenticated_decryption_test_case_8),
13401                 TEST_CASE_ST(ut_setup, ut_teardown,
13402                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
13403
13404                 /** AES GCM Authenticated Encryption 192 bits key */
13405                 TEST_CASE_ST(ut_setup, ut_teardown,
13406                         test_AES_GCM_auth_encryption_test_case_192_1),
13407                 TEST_CASE_ST(ut_setup, ut_teardown,
13408                         test_AES_GCM_auth_encryption_test_case_192_2),
13409                 TEST_CASE_ST(ut_setup, ut_teardown,
13410                         test_AES_GCM_auth_encryption_test_case_192_3),
13411                 TEST_CASE_ST(ut_setup, ut_teardown,
13412                         test_AES_GCM_auth_encryption_test_case_192_4),
13413                 TEST_CASE_ST(ut_setup, ut_teardown,
13414                         test_AES_GCM_auth_encryption_test_case_192_5),
13415                 TEST_CASE_ST(ut_setup, ut_teardown,
13416                         test_AES_GCM_auth_encryption_test_case_192_6),
13417                 TEST_CASE_ST(ut_setup, ut_teardown,
13418                         test_AES_GCM_auth_encryption_test_case_192_7),
13419
13420                 /** AES GCM Authenticated Decryption 192 bits key */
13421                 TEST_CASE_ST(ut_setup, ut_teardown,
13422                         test_AES_GCM_auth_decryption_test_case_192_1),
13423                 TEST_CASE_ST(ut_setup, ut_teardown,
13424                         test_AES_GCM_auth_decryption_test_case_192_2),
13425                 TEST_CASE_ST(ut_setup, ut_teardown,
13426                         test_AES_GCM_auth_decryption_test_case_192_3),
13427                 TEST_CASE_ST(ut_setup, ut_teardown,
13428                         test_AES_GCM_auth_decryption_test_case_192_4),
13429                 TEST_CASE_ST(ut_setup, ut_teardown,
13430                         test_AES_GCM_auth_decryption_test_case_192_5),
13431                 TEST_CASE_ST(ut_setup, ut_teardown,
13432                         test_AES_GCM_auth_decryption_test_case_192_6),
13433                 TEST_CASE_ST(ut_setup, ut_teardown,
13434                         test_AES_GCM_auth_decryption_test_case_192_7),
13435
13436                 /** AES GCM Authenticated Encryption 256 bits key */
13437                 TEST_CASE_ST(ut_setup, ut_teardown,
13438                         test_AES_GCM_auth_encryption_test_case_256_1),
13439                 TEST_CASE_ST(ut_setup, ut_teardown,
13440                         test_AES_GCM_auth_encryption_test_case_256_2),
13441                 TEST_CASE_ST(ut_setup, ut_teardown,
13442                         test_AES_GCM_auth_encryption_test_case_256_3),
13443                 TEST_CASE_ST(ut_setup, ut_teardown,
13444                         test_AES_GCM_auth_encryption_test_case_256_4),
13445                 TEST_CASE_ST(ut_setup, ut_teardown,
13446                         test_AES_GCM_auth_encryption_test_case_256_5),
13447                 TEST_CASE_ST(ut_setup, ut_teardown,
13448                         test_AES_GCM_auth_encryption_test_case_256_6),
13449                 TEST_CASE_ST(ut_setup, ut_teardown,
13450                         test_AES_GCM_auth_encryption_test_case_256_7),
13451
13452                 /** AES GCM Authenticated Decryption 256 bits key */
13453                 TEST_CASE_ST(ut_setup, ut_teardown,
13454                         test_AES_GCM_auth_decryption_test_case_256_1),
13455                 TEST_CASE_ST(ut_setup, ut_teardown,
13456                         test_AES_GCM_auth_decryption_test_case_256_2),
13457                 TEST_CASE_ST(ut_setup, ut_teardown,
13458                         test_AES_GCM_auth_decryption_test_case_256_3),
13459                 TEST_CASE_ST(ut_setup, ut_teardown,
13460                         test_AES_GCM_auth_decryption_test_case_256_4),
13461                 TEST_CASE_ST(ut_setup, ut_teardown,
13462                         test_AES_GCM_auth_decryption_test_case_256_5),
13463                 TEST_CASE_ST(ut_setup, ut_teardown,
13464                         test_AES_GCM_auth_decryption_test_case_256_6),
13465                 TEST_CASE_ST(ut_setup, ut_teardown,
13466                         test_AES_GCM_auth_decryption_test_case_256_7),
13467
13468                 /** AES GCM Authenticated Encryption big aad size */
13469                 TEST_CASE_ST(ut_setup, ut_teardown,
13470                         test_AES_GCM_auth_encryption_test_case_aad_1),
13471                 TEST_CASE_ST(ut_setup, ut_teardown,
13472                         test_AES_GCM_auth_encryption_test_case_aad_2),
13473
13474                 /** AES GCM Authenticated Decryption big aad size */
13475                 TEST_CASE_ST(ut_setup, ut_teardown,
13476                         test_AES_GCM_auth_decryption_test_case_aad_1),
13477                 TEST_CASE_ST(ut_setup, ut_teardown,
13478                         test_AES_GCM_auth_decryption_test_case_aad_2),
13479
13480                 /** Out of place tests */
13481                 TEST_CASE_ST(ut_setup, ut_teardown,
13482                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13483                 TEST_CASE_ST(ut_setup, ut_teardown,
13484                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13485
13486                 /** Session-less tests */
13487                 TEST_CASE_ST(ut_setup, ut_teardown,
13488                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13489                 TEST_CASE_ST(ut_setup, ut_teardown,
13490                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13491
13492                 /** AES GMAC Authentication */
13493                 TEST_CASE_ST(ut_setup, ut_teardown,
13494                         test_AES_GMAC_authentication_test_case_1),
13495                 TEST_CASE_ST(ut_setup, ut_teardown,
13496                         test_AES_GMAC_authentication_verify_test_case_1),
13497                 TEST_CASE_ST(ut_setup, ut_teardown,
13498                         test_AES_GMAC_authentication_test_case_2),
13499                 TEST_CASE_ST(ut_setup, ut_teardown,
13500                         test_AES_GMAC_authentication_verify_test_case_2),
13501                 TEST_CASE_ST(ut_setup, ut_teardown,
13502                         test_AES_GMAC_authentication_test_case_3),
13503                 TEST_CASE_ST(ut_setup, ut_teardown,
13504                         test_AES_GMAC_authentication_verify_test_case_3),
13505                 TEST_CASE_ST(ut_setup, ut_teardown,
13506                         test_AES_GMAC_authentication_test_case_4),
13507                 TEST_CASE_ST(ut_setup, ut_teardown,
13508                         test_AES_GMAC_authentication_verify_test_case_4),
13509                 TEST_CASE_ST(ut_setup, ut_teardown,
13510                         test_AES_GMAC_authentication_SGL_40B),
13511                 TEST_CASE_ST(ut_setup, ut_teardown,
13512                         test_AES_GMAC_authentication_SGL_80B),
13513                 TEST_CASE_ST(ut_setup, ut_teardown,
13514                         test_AES_GMAC_authentication_SGL_2048B),
13515                 TEST_CASE_ST(ut_setup, ut_teardown,
13516                         test_AES_GMAC_authentication_SGL_2047B),
13517
13518                 /** Chacha20-Poly1305 */
13519                 TEST_CASE_ST(ut_setup, ut_teardown,
13520                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
13521                 TEST_CASE_ST(ut_setup, ut_teardown,
13522                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
13523                 /** SNOW 3G encrypt only (UEA2) */
13524                 TEST_CASE_ST(ut_setup, ut_teardown,
13525                         test_snow3g_encryption_test_case_1),
13526                 TEST_CASE_ST(ut_setup, ut_teardown,
13527                         test_snow3g_encryption_test_case_2),
13528                 TEST_CASE_ST(ut_setup, ut_teardown,
13529                         test_snow3g_encryption_test_case_3),
13530                 TEST_CASE_ST(ut_setup, ut_teardown,
13531                         test_snow3g_encryption_test_case_4),
13532                 TEST_CASE_ST(ut_setup, ut_teardown,
13533                         test_snow3g_encryption_test_case_5),
13534
13535                 TEST_CASE_ST(ut_setup, ut_teardown,
13536                         test_snow3g_encryption_test_case_1_oop),
13537                 TEST_CASE_ST(ut_setup, ut_teardown,
13538                         test_snow3g_encryption_test_case_1_oop_sgl),
13539                 TEST_CASE_ST(ut_setup, ut_teardown,
13540                         test_snow3g_encryption_test_case_1_offset_oop),
13541                 TEST_CASE_ST(ut_setup, ut_teardown,
13542                         test_snow3g_decryption_test_case_1_oop),
13543
13544                 /** SNOW 3G generate auth, then encrypt (UEA2) */
13545                 TEST_CASE_ST(ut_setup, ut_teardown,
13546                         test_snow3g_auth_cipher_test_case_1),
13547                 TEST_CASE_ST(ut_setup, ut_teardown,
13548                         test_snow3g_auth_cipher_test_case_2),
13549                 TEST_CASE_ST(ut_setup, ut_teardown,
13550                         test_snow3g_auth_cipher_test_case_2_oop),
13551                 TEST_CASE_ST(ut_setup, ut_teardown,
13552                         test_snow3g_auth_cipher_part_digest_enc),
13553                 TEST_CASE_ST(ut_setup, ut_teardown,
13554                         test_snow3g_auth_cipher_part_digest_enc_oop),
13555                 TEST_CASE_ST(ut_setup, ut_teardown,
13556                         test_snow3g_auth_cipher_test_case_3_sgl),
13557                 TEST_CASE_ST(ut_setup, ut_teardown,
13558                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
13559                 TEST_CASE_ST(ut_setup, ut_teardown,
13560                         test_snow3g_auth_cipher_part_digest_enc_sgl),
13561                 TEST_CASE_ST(ut_setup, ut_teardown,
13562                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
13563
13564                 /** SNOW 3G decrypt (UEA2), then verify auth */
13565                 TEST_CASE_ST(ut_setup, ut_teardown,
13566                         test_snow3g_auth_cipher_verify_test_case_1),
13567                 TEST_CASE_ST(ut_setup, ut_teardown,
13568                         test_snow3g_auth_cipher_verify_test_case_2),
13569                 TEST_CASE_ST(ut_setup, ut_teardown,
13570                         test_snow3g_auth_cipher_verify_test_case_2_oop),
13571                 TEST_CASE_ST(ut_setup, ut_teardown,
13572                         test_snow3g_auth_cipher_verify_part_digest_enc),
13573                 TEST_CASE_ST(ut_setup, ut_teardown,
13574                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
13575                 TEST_CASE_ST(ut_setup, ut_teardown,
13576                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
13577                 TEST_CASE_ST(ut_setup, ut_teardown,
13578                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
13579                 TEST_CASE_ST(ut_setup, ut_teardown,
13580                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
13581                 TEST_CASE_ST(ut_setup, ut_teardown,
13582                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
13583
13584                 /** SNOW 3G decrypt only (UEA2) */
13585                 TEST_CASE_ST(ut_setup, ut_teardown,
13586                         test_snow3g_decryption_test_case_1),
13587                 TEST_CASE_ST(ut_setup, ut_teardown,
13588                         test_snow3g_decryption_test_case_2),
13589                 TEST_CASE_ST(ut_setup, ut_teardown,
13590                         test_snow3g_decryption_test_case_3),
13591                 TEST_CASE_ST(ut_setup, ut_teardown,
13592                         test_snow3g_decryption_test_case_4),
13593                 TEST_CASE_ST(ut_setup, ut_teardown,
13594                         test_snow3g_decryption_test_case_5),
13595                 TEST_CASE_ST(ut_setup, ut_teardown,
13596                         test_snow3g_decryption_with_digest_test_case_1),
13597                 TEST_CASE_ST(ut_setup, ut_teardown,
13598                         test_snow3g_hash_generate_test_case_1),
13599                 TEST_CASE_ST(ut_setup, ut_teardown,
13600                         test_snow3g_hash_generate_test_case_2),
13601                 TEST_CASE_ST(ut_setup, ut_teardown,
13602                         test_snow3g_hash_generate_test_case_3),
13603                 /* Tests with buffers which length is not byte-aligned */
13604                 TEST_CASE_ST(ut_setup, ut_teardown,
13605                         test_snow3g_hash_generate_test_case_4),
13606                 TEST_CASE_ST(ut_setup, ut_teardown,
13607                         test_snow3g_hash_generate_test_case_5),
13608                 TEST_CASE_ST(ut_setup, ut_teardown,
13609                         test_snow3g_hash_generate_test_case_6),
13610                 TEST_CASE_ST(ut_setup, ut_teardown,
13611                         test_snow3g_hash_verify_test_case_1),
13612                 TEST_CASE_ST(ut_setup, ut_teardown,
13613                         test_snow3g_hash_verify_test_case_2),
13614                 TEST_CASE_ST(ut_setup, ut_teardown,
13615                         test_snow3g_hash_verify_test_case_3),
13616                 /* Tests with buffers which length is not byte-aligned */
13617                 TEST_CASE_ST(ut_setup, ut_teardown,
13618                         test_snow3g_hash_verify_test_case_4),
13619                 TEST_CASE_ST(ut_setup, ut_teardown,
13620                         test_snow3g_hash_verify_test_case_5),
13621                 TEST_CASE_ST(ut_setup, ut_teardown,
13622                         test_snow3g_hash_verify_test_case_6),
13623                 TEST_CASE_ST(ut_setup, ut_teardown,
13624                         test_snow3g_cipher_auth_test_case_1),
13625                 TEST_CASE_ST(ut_setup, ut_teardown,
13626                         test_snow3g_auth_cipher_with_digest_test_case_1),
13627
13628                 /** ZUC encrypt only (EEA3) */
13629                 TEST_CASE_ST(ut_setup, ut_teardown,
13630                         test_zuc_encryption_test_case_1),
13631                 TEST_CASE_ST(ut_setup, ut_teardown,
13632                         test_zuc_encryption_test_case_2),
13633                 TEST_CASE_ST(ut_setup, ut_teardown,
13634                         test_zuc_encryption_test_case_3),
13635                 TEST_CASE_ST(ut_setup, ut_teardown,
13636                         test_zuc_encryption_test_case_4),
13637                 TEST_CASE_ST(ut_setup, ut_teardown,
13638                         test_zuc_encryption_test_case_5),
13639                 TEST_CASE_ST(ut_setup, ut_teardown,
13640                         test_zuc_encryption_test_case_6_sgl),
13641
13642                 /** ZUC authenticate (EIA3) */
13643                 TEST_CASE_ST(ut_setup, ut_teardown,
13644                         test_zuc_hash_generate_test_case_1),
13645                 TEST_CASE_ST(ut_setup, ut_teardown,
13646                         test_zuc_hash_generate_test_case_2),
13647                 TEST_CASE_ST(ut_setup, ut_teardown,
13648                         test_zuc_hash_generate_test_case_3),
13649                 TEST_CASE_ST(ut_setup, ut_teardown,
13650                         test_zuc_hash_generate_test_case_4),
13651                 TEST_CASE_ST(ut_setup, ut_teardown,
13652                         test_zuc_hash_generate_test_case_5),
13653                 TEST_CASE_ST(ut_setup, ut_teardown,
13654                         test_zuc_hash_generate_test_case_6),
13655                 TEST_CASE_ST(ut_setup, ut_teardown,
13656                         test_zuc_hash_generate_test_case_7),
13657                 TEST_CASE_ST(ut_setup, ut_teardown,
13658                         test_zuc_hash_generate_test_case_8),
13659
13660                 /** ZUC alg-chain (EEA3/EIA3) */
13661                 TEST_CASE_ST(ut_setup, ut_teardown,
13662                         test_zuc_cipher_auth_test_case_1),
13663                 TEST_CASE_ST(ut_setup, ut_teardown,
13664                         test_zuc_cipher_auth_test_case_2),
13665
13666                 /** ZUC generate auth, then encrypt (EEA3) */
13667                 TEST_CASE_ST(ut_setup, ut_teardown,
13668                         test_zuc_auth_cipher_test_case_1),
13669                 TEST_CASE_ST(ut_setup, ut_teardown,
13670                         test_zuc_auth_cipher_test_case_1_oop),
13671                 TEST_CASE_ST(ut_setup, ut_teardown,
13672                         test_zuc_auth_cipher_test_case_1_sgl),
13673                 TEST_CASE_ST(ut_setup, ut_teardown,
13674                         test_zuc_auth_cipher_test_case_1_oop_sgl),
13675
13676                 /** ZUC decrypt (EEA3), then verify auth */
13677                 TEST_CASE_ST(ut_setup, ut_teardown,
13678                         test_zuc_auth_cipher_verify_test_case_1),
13679                 TEST_CASE_ST(ut_setup, ut_teardown,
13680                         test_zuc_auth_cipher_verify_test_case_1_oop),
13681                 TEST_CASE_ST(ut_setup, ut_teardown,
13682                         test_zuc_auth_cipher_verify_test_case_1_sgl),
13683                 TEST_CASE_ST(ut_setup, ut_teardown,
13684                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
13685
13686                 /** HMAC_MD5 Authentication */
13687                 TEST_CASE_ST(ut_setup, ut_teardown,
13688                         test_MD5_HMAC_generate_case_1),
13689                 TEST_CASE_ST(ut_setup, ut_teardown,
13690                         test_MD5_HMAC_verify_case_1),
13691                 TEST_CASE_ST(ut_setup, ut_teardown,
13692                         test_MD5_HMAC_generate_case_2),
13693                 TEST_CASE_ST(ut_setup, ut_teardown,
13694                         test_MD5_HMAC_verify_case_2),
13695
13696                 /** KASUMI hash only (UIA1) */
13697                 TEST_CASE_ST(ut_setup, ut_teardown,
13698                         test_kasumi_hash_generate_test_case_1),
13699                 TEST_CASE_ST(ut_setup, ut_teardown,
13700                         test_kasumi_hash_generate_test_case_2),
13701                 TEST_CASE_ST(ut_setup, ut_teardown,
13702                         test_kasumi_hash_generate_test_case_3),
13703                 TEST_CASE_ST(ut_setup, ut_teardown,
13704                         test_kasumi_hash_generate_test_case_4),
13705                 TEST_CASE_ST(ut_setup, ut_teardown,
13706                         test_kasumi_hash_generate_test_case_5),
13707                 TEST_CASE_ST(ut_setup, ut_teardown,
13708                         test_kasumi_hash_generate_test_case_6),
13709
13710                 TEST_CASE_ST(ut_setup, ut_teardown,
13711                         test_kasumi_hash_verify_test_case_1),
13712                 TEST_CASE_ST(ut_setup, ut_teardown,
13713                         test_kasumi_hash_verify_test_case_2),
13714                 TEST_CASE_ST(ut_setup, ut_teardown,
13715                         test_kasumi_hash_verify_test_case_3),
13716                 TEST_CASE_ST(ut_setup, ut_teardown,
13717                         test_kasumi_hash_verify_test_case_4),
13718                 TEST_CASE_ST(ut_setup, ut_teardown,
13719                         test_kasumi_hash_verify_test_case_5),
13720
13721                 /** KASUMI encrypt only (UEA1) */
13722                 TEST_CASE_ST(ut_setup, ut_teardown,
13723                         test_kasumi_encryption_test_case_1),
13724                 TEST_CASE_ST(ut_setup, ut_teardown,
13725                         test_kasumi_encryption_test_case_1_sgl),
13726                 TEST_CASE_ST(ut_setup, ut_teardown,
13727                         test_kasumi_encryption_test_case_1_oop),
13728                 TEST_CASE_ST(ut_setup, ut_teardown,
13729                         test_kasumi_encryption_test_case_1_oop_sgl),
13730                 TEST_CASE_ST(ut_setup, ut_teardown,
13731                         test_kasumi_encryption_test_case_2),
13732                 TEST_CASE_ST(ut_setup, ut_teardown,
13733                         test_kasumi_encryption_test_case_3),
13734                 TEST_CASE_ST(ut_setup, ut_teardown,
13735                         test_kasumi_encryption_test_case_4),
13736                 TEST_CASE_ST(ut_setup, ut_teardown,
13737                         test_kasumi_encryption_test_case_5),
13738
13739                 /** KASUMI decrypt only (UEA1) */
13740                 TEST_CASE_ST(ut_setup, ut_teardown,
13741                         test_kasumi_decryption_test_case_1),
13742                 TEST_CASE_ST(ut_setup, ut_teardown,
13743                         test_kasumi_decryption_test_case_2),
13744                 TEST_CASE_ST(ut_setup, ut_teardown,
13745                         test_kasumi_decryption_test_case_3),
13746                 TEST_CASE_ST(ut_setup, ut_teardown,
13747                         test_kasumi_decryption_test_case_4),
13748                 TEST_CASE_ST(ut_setup, ut_teardown,
13749                         test_kasumi_decryption_test_case_5),
13750                 TEST_CASE_ST(ut_setup, ut_teardown,
13751                         test_kasumi_decryption_test_case_1_oop),
13752
13753                 TEST_CASE_ST(ut_setup, ut_teardown,
13754                         test_kasumi_cipher_auth_test_case_1),
13755
13756                 /** KASUMI generate auth, then encrypt (F8) */
13757                 TEST_CASE_ST(ut_setup, ut_teardown,
13758                         test_kasumi_auth_cipher_test_case_1),
13759                 TEST_CASE_ST(ut_setup, ut_teardown,
13760                         test_kasumi_auth_cipher_test_case_2),
13761                 TEST_CASE_ST(ut_setup, ut_teardown,
13762                         test_kasumi_auth_cipher_test_case_2_oop),
13763                 TEST_CASE_ST(ut_setup, ut_teardown,
13764                         test_kasumi_auth_cipher_test_case_2_sgl),
13765                 TEST_CASE_ST(ut_setup, ut_teardown,
13766                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
13767
13768                 /** KASUMI decrypt (F8), then verify auth */
13769                 TEST_CASE_ST(ut_setup, ut_teardown,
13770                         test_kasumi_auth_cipher_verify_test_case_1),
13771                 TEST_CASE_ST(ut_setup, ut_teardown,
13772                         test_kasumi_auth_cipher_verify_test_case_2),
13773                 TEST_CASE_ST(ut_setup, ut_teardown,
13774                         test_kasumi_auth_cipher_verify_test_case_2_oop),
13775                 TEST_CASE_ST(ut_setup, ut_teardown,
13776                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
13777                 TEST_CASE_ST(ut_setup, ut_teardown,
13778                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
13779
13780                 /** ESN Testcase */
13781                 TEST_CASE_ST(ut_setup, ut_teardown,
13782                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13783                 TEST_CASE_ST(ut_setup, ut_teardown,
13784                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13785
13786                 /** Negative tests */
13787                 TEST_CASE_ST(ut_setup, ut_teardown,
13788                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13789                 TEST_CASE_ST(ut_setup, ut_teardown,
13790                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13791                 TEST_CASE_ST(ut_setup, ut_teardown,
13792                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
13793                 TEST_CASE_ST(ut_setup, ut_teardown,
13794                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13795                 TEST_CASE_ST(ut_setup, ut_teardown,
13796                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13797                 TEST_CASE_ST(ut_setup, ut_teardown,
13798                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13799                 TEST_CASE_ST(ut_setup, ut_teardown,
13800                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
13801                 TEST_CASE_ST(ut_setup, ut_teardown,
13802                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
13803                 TEST_CASE_ST(ut_setup, ut_teardown,
13804                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
13805                 TEST_CASE_ST(ut_setup, ut_teardown,
13806                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13807                 TEST_CASE_ST(ut_setup, ut_teardown,
13808                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13809                 TEST_CASE_ST(ut_setup, ut_teardown,
13810                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13811                 TEST_CASE_ST(ut_setup, ut_teardown,
13812                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
13813                 TEST_CASE_ST(ut_setup, ut_teardown,
13814                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
13815                 TEST_CASE_ST(ut_setup, ut_teardown,
13816                         authentication_verify_AES128_GMAC_fail_data_corrupt),
13817                 TEST_CASE_ST(ut_setup, ut_teardown,
13818                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
13819                 TEST_CASE_ST(ut_setup, ut_teardown,
13820                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13821                 TEST_CASE_ST(ut_setup, ut_teardown,
13822                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13823
13824                 /** Mixed CIPHER + HASH algorithms */
13825                 /** AUTH AES CMAC + CIPHER AES CTR */
13826                 TEST_CASE_ST(ut_setup, ut_teardown,
13827                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
13828                 TEST_CASE_ST(ut_setup, ut_teardown,
13829                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13830                 TEST_CASE_ST(ut_setup, ut_teardown,
13831                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13832                 TEST_CASE_ST(ut_setup, ut_teardown,
13833                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13834                 TEST_CASE_ST(ut_setup, ut_teardown,
13835                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
13836                 TEST_CASE_ST(ut_setup, ut_teardown,
13837                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13838                 TEST_CASE_ST(ut_setup, ut_teardown,
13839                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13840                 TEST_CASE_ST(ut_setup, ut_teardown,
13841                    test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13842
13843                 /** AUTH ZUC + CIPHER SNOW3G */
13844                 TEST_CASE_ST(ut_setup, ut_teardown,
13845                         test_auth_zuc_cipher_snow_test_case_1),
13846                 TEST_CASE_ST(ut_setup, ut_teardown,
13847                         test_verify_auth_zuc_cipher_snow_test_case_1),
13848                 /** AUTH AES CMAC + CIPHER SNOW3G */
13849                 TEST_CASE_ST(ut_setup, ut_teardown,
13850                         test_auth_aes_cmac_cipher_snow_test_case_1),
13851                 TEST_CASE_ST(ut_setup, ut_teardown,
13852                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
13853                 /** AUTH ZUC + CIPHER AES CTR */
13854                 TEST_CASE_ST(ut_setup, ut_teardown,
13855                         test_auth_zuc_cipher_aes_ctr_test_case_1),
13856                 TEST_CASE_ST(ut_setup, ut_teardown,
13857                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
13858                 /** AUTH SNOW3G + CIPHER AES CTR */
13859                 TEST_CASE_ST(ut_setup, ut_teardown,
13860                         test_auth_snow_cipher_aes_ctr_test_case_1),
13861                 TEST_CASE_ST(ut_setup, ut_teardown,
13862                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
13863                 /** AUTH SNOW3G + CIPHER ZUC */
13864                 TEST_CASE_ST(ut_setup, ut_teardown,
13865                         test_auth_snow_cipher_zuc_test_case_1),
13866                 TEST_CASE_ST(ut_setup, ut_teardown,
13867                         test_verify_auth_snow_cipher_zuc_test_case_1),
13868                 /** AUTH AES CMAC + CIPHER ZUC */
13869                 TEST_CASE_ST(ut_setup, ut_teardown,
13870                         test_auth_aes_cmac_cipher_zuc_test_case_1),
13871                 TEST_CASE_ST(ut_setup, ut_teardown,
13872                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
13873
13874                 /** AUTH NULL + CIPHER SNOW3G */
13875                 TEST_CASE_ST(ut_setup, ut_teardown,
13876                         test_auth_null_cipher_snow_test_case_1),
13877                 TEST_CASE_ST(ut_setup, ut_teardown,
13878                         test_verify_auth_null_cipher_snow_test_case_1),
13879                 /** AUTH NULL + CIPHER ZUC */
13880                 TEST_CASE_ST(ut_setup, ut_teardown,
13881                         test_auth_null_cipher_zuc_test_case_1),
13882                 TEST_CASE_ST(ut_setup, ut_teardown,
13883                         test_verify_auth_null_cipher_zuc_test_case_1),
13884                 /** AUTH SNOW3G + CIPHER NULL */
13885                 TEST_CASE_ST(ut_setup, ut_teardown,
13886                         test_auth_snow_cipher_null_test_case_1),
13887                 TEST_CASE_ST(ut_setup, ut_teardown,
13888                         test_verify_auth_snow_cipher_null_test_case_1),
13889                 /** AUTH ZUC + CIPHER NULL */
13890                 TEST_CASE_ST(ut_setup, ut_teardown,
13891                         test_auth_zuc_cipher_null_test_case_1),
13892                 TEST_CASE_ST(ut_setup, ut_teardown,
13893                         test_verify_auth_zuc_cipher_null_test_case_1),
13894                 /** AUTH NULL + CIPHER AES CTR */
13895                 TEST_CASE_ST(ut_setup, ut_teardown,
13896                         test_auth_null_cipher_aes_ctr_test_case_1),
13897                 TEST_CASE_ST(ut_setup, ut_teardown,
13898                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
13899                 /** AUTH AES CMAC + CIPHER NULL */
13900                 TEST_CASE_ST(ut_setup, ut_teardown,
13901                         test_auth_aes_cmac_cipher_null_test_case_1),
13902                 TEST_CASE_ST(ut_setup, ut_teardown,
13903                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
13904
13905 #ifdef RTE_LIB_SECURITY
13906                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13907                         test_PDCP_PROTO_all),
13908                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13909                         test_DOCSIS_PROTO_all),
13910 #endif
13911                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
13912                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
13913                 TEST_CASES_END() /**< NULL terminate unit test array */
13914         }
13915 };
13916
13917 static struct unit_test_suite cryptodev_virtio_testsuite = {
13918         .suite_name = "Crypto VIRTIO Unit Test Suite",
13919         .setup = testsuite_setup,
13920         .teardown = testsuite_teardown,
13921         .unit_test_cases = {
13922                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13923
13924                 TEST_CASES_END() /**< NULL terminate unit test array */
13925         }
13926 };
13927
13928 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
13929         .suite_name = "Crypto CAAM JR Unit Test Suite",
13930         .setup = testsuite_setup,
13931         .teardown = testsuite_teardown,
13932         .unit_test_cases = {
13933                 TEST_CASE_ST(ut_setup, ut_teardown,
13934                              test_device_configure_invalid_dev_id),
13935                 TEST_CASE_ST(ut_setup, ut_teardown,
13936                              test_multi_session),
13937
13938                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13939                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13940                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13941                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13942                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13943
13944                 TEST_CASES_END() /**< NULL terminate unit test array */
13945         }
13946 };
13947
13948 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
13949         .suite_name = "Crypto Device Marvell Component Test Suite",
13950         .setup = testsuite_setup,
13951         .teardown = testsuite_teardown,
13952         .unit_test_cases = {
13953                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13954                 TEST_CASE_ST(ut_setup, ut_teardown,
13955                                 test_multi_session_random_usage),
13956                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13957                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13958                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13959                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13960                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13961
13962                 /** Negative tests */
13963                 TEST_CASE_ST(ut_setup, ut_teardown,
13964                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13965                 TEST_CASE_ST(ut_setup, ut_teardown,
13966                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13967                 TEST_CASE_ST(ut_setup, ut_teardown,
13968                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13969                 TEST_CASE_ST(ut_setup, ut_teardown,
13970                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13971
13972                 TEST_CASES_END() /**< NULL terminate unit test array */
13973         }
13974 };
13975
13976 static struct unit_test_suite cryptodev_ccp_testsuite  = {
13977         .suite_name = "Crypto Device CCP Unit Test Suite",
13978         .setup = testsuite_setup,
13979         .teardown = testsuite_teardown,
13980         .unit_test_cases = {
13981                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13982                 TEST_CASE_ST(ut_setup, ut_teardown,
13983                                 test_multi_session_random_usage),
13984                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13985                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13986                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13987                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13988                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13989
13990                 /** Negative tests */
13991                 TEST_CASE_ST(ut_setup, ut_teardown,
13992                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13993                 TEST_CASE_ST(ut_setup, ut_teardown,
13994                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13995                 TEST_CASE_ST(ut_setup, ut_teardown,
13996                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13997                 TEST_CASE_ST(ut_setup, ut_teardown,
13998                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13999
14000                 TEST_CASES_END() /**< NULL terminate unit test array */
14001         }
14002 };
14003
14004 static int
14005 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
14006 {
14007         gbl_driver_id = rte_cryptodev_driver_id_get(
14008                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14009
14010         if (gbl_driver_id == -1) {
14011                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
14012                 return TEST_SKIPPED;
14013         }
14014
14015         return unit_test_suite_runner(&cryptodev_testsuite);
14016 }
14017
14018 static int
14019 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
14020 {
14021         gbl_driver_id = rte_cryptodev_driver_id_get(
14022                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
14023
14024         if (gbl_driver_id == -1) {
14025                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded.\n");
14026                 return TEST_FAILED;
14027         }
14028
14029         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
14030 }
14031
14032 static int
14033 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
14034 {
14035         gbl_driver_id = rte_cryptodev_driver_id_get(
14036                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14037
14038         if (gbl_driver_id == -1) {
14039                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
14040                 return TEST_SKIPPED;
14041         }
14042
14043         return unit_test_suite_runner(&cryptodev_testsuite);
14044 }
14045
14046 static int
14047 test_cryptodev_cpu_aesni_mb(void)
14048 {
14049         int32_t rc;
14050         enum rte_security_session_action_type at;
14051
14052         gbl_driver_id = rte_cryptodev_driver_id_get(
14053                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14054
14055         if (gbl_driver_id == -1) {
14056                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
14057                 return TEST_SKIPPED;
14058         }
14059
14060         at = gbl_action_type;
14061         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14062         rc = unit_test_suite_runner(&cryptodev_testsuite);
14063         gbl_action_type = at;
14064         return rc;
14065 }
14066
14067 static int
14068 test_cryptodev_openssl(void)
14069 {
14070         gbl_driver_id = rte_cryptodev_driver_id_get(
14071                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
14072
14073         if (gbl_driver_id == -1) {
14074                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
14075                 return TEST_SKIPPED;
14076         }
14077
14078         return unit_test_suite_runner(&cryptodev_testsuite);
14079 }
14080
14081 static int
14082 test_cryptodev_aesni_gcm(void)
14083 {
14084         gbl_driver_id = rte_cryptodev_driver_id_get(
14085                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14086
14087         if (gbl_driver_id == -1) {
14088                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
14089                 return TEST_SKIPPED;
14090         }
14091
14092         return unit_test_suite_runner(&cryptodev_testsuite);
14093 }
14094
14095 static int
14096 test_cryptodev_cpu_aesni_gcm(void)
14097 {
14098         int32_t rc;
14099         enum rte_security_session_action_type at;
14100
14101         gbl_driver_id = rte_cryptodev_driver_id_get(
14102                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
14103
14104         if (gbl_driver_id == -1) {
14105                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
14106                 return TEST_SKIPPED;
14107         }
14108
14109         at = gbl_action_type;
14110         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
14111         rc = unit_test_suite_runner(&cryptodev_testsuite);
14112         gbl_action_type = at;
14113         return rc;
14114 }
14115
14116 static int
14117 test_cryptodev_null(void)
14118 {
14119         gbl_driver_id = rte_cryptodev_driver_id_get(
14120                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
14121
14122         if (gbl_driver_id == -1) {
14123                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded.\n");
14124                 return TEST_SKIPPED;
14125         }
14126
14127         return unit_test_suite_runner(&cryptodev_testsuite);
14128 }
14129
14130 static int
14131 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
14132 {
14133         gbl_driver_id = rte_cryptodev_driver_id_get(
14134                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
14135
14136         if (gbl_driver_id == -1) {
14137                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded.\n");
14138                 return TEST_SKIPPED;
14139         }
14140
14141         return unit_test_suite_runner(&cryptodev_testsuite);
14142 }
14143
14144 static int
14145 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
14146 {
14147         gbl_driver_id = rte_cryptodev_driver_id_get(
14148                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
14149
14150         if (gbl_driver_id == -1) {
14151                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
14152                 return TEST_SKIPPED;
14153         }
14154
14155         return unit_test_suite_runner(&cryptodev_testsuite);
14156 }
14157
14158 static int
14159 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
14160 {
14161         gbl_driver_id = rte_cryptodev_driver_id_get(
14162                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
14163
14164         if (gbl_driver_id == -1) {
14165                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
14166                 return TEST_SKIPPED;
14167         }
14168
14169         return unit_test_suite_runner(&cryptodev_testsuite);
14170 }
14171
14172 static int
14173 test_cryptodev_armv8(void)
14174 {
14175         gbl_driver_id = rte_cryptodev_driver_id_get(
14176                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
14177
14178         if (gbl_driver_id == -1) {
14179                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded.\n");
14180                 return TEST_SKIPPED;
14181         }
14182
14183         return unit_test_suite_runner(&cryptodev_testsuite);
14184 }
14185
14186 static int
14187 test_cryptodev_mrvl(void)
14188 {
14189         gbl_driver_id = rte_cryptodev_driver_id_get(
14190                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
14191
14192         if (gbl_driver_id == -1) {
14193                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded.\n");
14194                 return TEST_SKIPPED;
14195         }
14196
14197         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
14198 }
14199
14200 #ifdef RTE_CRYPTO_SCHEDULER
14201
14202 static int
14203 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
14204 {
14205         gbl_driver_id = rte_cryptodev_driver_id_get(
14206                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14207
14208         if (gbl_driver_id == -1) {
14209                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
14210                 return TEST_SKIPPED;
14211         }
14212
14213         if (rte_cryptodev_driver_id_get(
14214                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
14215                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
14216                 return TEST_SKIPPED;
14217 }
14218         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
14219 }
14220
14221 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
14222
14223 #endif
14224
14225 static int
14226 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14227 {
14228         gbl_driver_id = rte_cryptodev_driver_id_get(
14229                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
14230
14231         if (gbl_driver_id == -1) {
14232                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded.\n");
14233                 return TEST_SKIPPED;
14234         }
14235
14236         return unit_test_suite_runner(&cryptodev_testsuite);
14237 }
14238
14239 static int
14240 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14241 {
14242         gbl_driver_id = rte_cryptodev_driver_id_get(
14243                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14244
14245         if (gbl_driver_id == -1) {
14246                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded.\n");
14247                 return TEST_SKIPPED;
14248         }
14249
14250         return unit_test_suite_runner(&cryptodev_testsuite);
14251 }
14252
14253 static int
14254 test_cryptodev_ccp(void)
14255 {
14256         gbl_driver_id = rte_cryptodev_driver_id_get(
14257                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14258
14259         if (gbl_driver_id == -1) {
14260                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded.\n");
14261                 return TEST_FAILED;
14262         }
14263
14264         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
14265 }
14266
14267 static int
14268 test_cryptodev_octeontx(void)
14269 {
14270         gbl_driver_id = rte_cryptodev_driver_id_get(
14271                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14272         if (gbl_driver_id == -1) {
14273                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
14274                 return TEST_FAILED;
14275         }
14276         return unit_test_suite_runner(&cryptodev_testsuite);
14277 }
14278
14279 static int
14280 test_cryptodev_octeontx2(void)
14281 {
14282         gbl_driver_id = rte_cryptodev_driver_id_get(
14283                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14284         if (gbl_driver_id == -1) {
14285                 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded.\n");
14286                 return TEST_FAILED;
14287         }
14288         return unit_test_suite_runner(&cryptodev_testsuite);
14289 }
14290
14291 static int
14292 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
14293 {
14294         gbl_driver_id = rte_cryptodev_driver_id_get(
14295                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14296
14297         if (gbl_driver_id == -1) {
14298                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded.\n");
14299                 return TEST_FAILED;
14300         }
14301
14302         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
14303 }
14304
14305 static int
14306 test_cryptodev_nitrox(void)
14307 {
14308         gbl_driver_id = rte_cryptodev_driver_id_get(
14309                         RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14310
14311         if (gbl_driver_id == -1) {
14312                 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded.\n");
14313                 return TEST_FAILED;
14314         }
14315
14316         return unit_test_suite_runner(&cryptodev_testsuite);
14317 }
14318
14319 static int
14320 test_cryptodev_bcmfs(void)
14321 {
14322         gbl_driver_id = rte_cryptodev_driver_id_get(
14323                         RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
14324
14325         if (gbl_driver_id == -1) {
14326                 RTE_LOG(ERR, USER1, "BCMFS PMD must be loaded.\n");
14327                 return TEST_FAILED;
14328         }
14329
14330         return unit_test_suite_runner(&cryptodev_testsuite);
14331 }
14332
14333 static int
14334 test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
14335 {
14336         int ret;
14337
14338         gbl_driver_id = rte_cryptodev_driver_id_get(
14339                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14340
14341         if (gbl_driver_id == -1) {
14342                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
14343                 return TEST_SKIPPED;
14344         }
14345
14346         global_api_test_type = CRYPTODEV_RAW_API_TEST;
14347         ret = unit_test_suite_runner(&cryptodev_testsuite);
14348         global_api_test_type = CRYPTODEV_API_TEST;
14349
14350         return ret;
14351 }
14352
14353 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
14354                 test_cryptodev_qat_raw_api);
14355 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14356 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14357 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
14358         test_cryptodev_cpu_aesni_mb);
14359 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14360 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14361 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
14362         test_cryptodev_cpu_aesni_gcm);
14363 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14364 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14365 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14366 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14367 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14368 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14369 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14370 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14371 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14372 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14373 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14374 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14375 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14376 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
14377 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);