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
6758         /* Check if device supports particular algorithms separately */
6759         if (test_mixed_check_if_unsupported(tdata))
6760                 return -ENOTSUP;
6761         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6762                 return -ENOTSUP;
6763
6764         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6765
6766         uint64_t feat_flags = dev_info.feature_flags;
6767
6768         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6769                 printf("Device doesn't support digest encrypted.\n");
6770                 return -ENOTSUP;
6771         }
6772
6773         if (op_mode == OUT_OF_PLACE)
6774                 return -ENOTSUP;
6775
6776         /* Create the session */
6777         if (verify)
6778                 retval = create_wireless_algo_cipher_auth_session(
6779                                 ts_params->valid_devs[0],
6780                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6781                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6782                                 tdata->auth_algo,
6783                                 tdata->cipher_algo,
6784                                 tdata->auth_key.data, tdata->auth_key.len,
6785                                 tdata->auth_iv.len, tdata->digest_enc.len,
6786                                 tdata->cipher_iv.len);
6787         else
6788                 retval = create_wireless_algo_auth_cipher_session(
6789                                 ts_params->valid_devs[0],
6790                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6791                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6792                                 tdata->auth_algo,
6793                                 tdata->cipher_algo,
6794                                 tdata->auth_key.data, tdata->auth_key.len,
6795                                 tdata->auth_iv.len, tdata->digest_enc.len,
6796                                 tdata->cipher_iv.len);
6797         if (retval < 0)
6798                 return retval;
6799
6800         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6801         if (op_mode == OUT_OF_PLACE)
6802                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6803
6804         /* clear mbuf payload */
6805         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6806                 rte_pktmbuf_tailroom(ut_params->ibuf));
6807         if (op_mode == OUT_OF_PLACE) {
6808
6809                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6810                                 rte_pktmbuf_tailroom(ut_params->obuf));
6811         }
6812
6813         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6814         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6815         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6816         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6817
6818         if (verify) {
6819                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6820                                 ciphertext_pad_len);
6821                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6822                 if (op_mode == OUT_OF_PLACE)
6823                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6824                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6825                                 ciphertext_len);
6826         } else {
6827                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6828                                 plaintext_pad_len);
6829                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6830                 if (op_mode == OUT_OF_PLACE)
6831                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6832                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6833         }
6834
6835         /* Create the operation */
6836         retval = create_wireless_algo_auth_cipher_operation(
6837                         tdata->digest_enc.data, tdata->digest_enc.len,
6838                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6839                         tdata->auth_iv.data, tdata->auth_iv.len,
6840                         (tdata->digest_enc.offset == 0 ?
6841                                 plaintext_pad_len
6842                                 : tdata->digest_enc.offset),
6843                         tdata->validCipherLen.len_bits,
6844                         tdata->cipher.offset_bits,
6845                         tdata->validAuthLen.len_bits,
6846                         tdata->auth.offset_bits,
6847                         op_mode, 0, verify);
6848
6849         if (retval < 0)
6850                 return retval;
6851
6852         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6853                         ut_params->op);
6854
6855         /* Check if the op failed because the device doesn't */
6856         /* support this particular combination of algorithms */
6857         if (ut_params->op == NULL && ut_params->op->status ==
6858                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6859                 printf("Device doesn't support this mixed combination. "
6860                                 "Test Skipped.\n");
6861                 return -ENOTSUP;
6862         }
6863
6864         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6865
6866         ut_params->obuf = (op_mode == IN_PLACE ?
6867                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6868
6869         if (verify) {
6870                 if (ut_params->obuf)
6871                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6872                                                         uint8_t *);
6873                 else
6874                         plaintext = ciphertext +
6875                                         (tdata->cipher.offset_bits >> 3);
6876
6877                 debug_hexdump(stdout, "plaintext:", plaintext,
6878                                 tdata->plaintext.len_bits >> 3);
6879                 debug_hexdump(stdout, "plaintext expected:",
6880                                 tdata->plaintext.data,
6881                                 tdata->plaintext.len_bits >> 3);
6882         } else {
6883                 if (ut_params->obuf)
6884                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6885                                         uint8_t *);
6886                 else
6887                         ciphertext = plaintext;
6888
6889                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6890                                 ciphertext_len);
6891                 debug_hexdump(stdout, "ciphertext expected:",
6892                                 tdata->ciphertext.data,
6893                                 tdata->ciphertext.len_bits >> 3);
6894
6895                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6896                                 + (tdata->digest_enc.offset == 0 ?
6897                 plaintext_pad_len : tdata->digest_enc.offset);
6898
6899                 debug_hexdump(stdout, "digest:", ut_params->digest,
6900                                 tdata->digest_enc.len);
6901                 debug_hexdump(stdout, "digest expected:",
6902                                 tdata->digest_enc.data,
6903                                 tdata->digest_enc.len);
6904         }
6905
6906         /* Validate obuf */
6907         if (verify) {
6908                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6909                                 plaintext,
6910                                 tdata->plaintext.data,
6911                                 tdata->plaintext.len_bits >> 3,
6912                                 "Plaintext data not as expected");
6913         } else {
6914                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6915                                 ciphertext,
6916                                 tdata->ciphertext.data,
6917                                 tdata->validDataLen.len_bits,
6918                                 "Ciphertext data not as expected");
6919
6920                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6921                                 ut_params->digest,
6922                                 tdata->digest_enc.data,
6923                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6924                                 "Generated auth tag not as expected");
6925         }
6926
6927         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6928                         "crypto op processing failed");
6929
6930         return 0;
6931 }
6932
6933 static int
6934 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6935         uint8_t op_mode, uint8_t verify)
6936 {
6937         struct crypto_testsuite_params *ts_params = &testsuite_params;
6938         struct crypto_unittest_params *ut_params = &unittest_params;
6939
6940         int retval;
6941
6942         const uint8_t *plaintext = NULL;
6943         const uint8_t *ciphertext = NULL;
6944         const uint8_t *digest = NULL;
6945         unsigned int plaintext_pad_len;
6946         unsigned int plaintext_len;
6947         unsigned int ciphertext_pad_len;
6948         unsigned int ciphertext_len;
6949         uint8_t buffer[10000];
6950         uint8_t digest_buffer[10000];
6951
6952         struct rte_cryptodev_info dev_info;
6953
6954         /* Check if device supports particular algorithms */
6955         if (test_mixed_check_if_unsupported(tdata))
6956                 return -ENOTSUP;
6957         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6958                 return -ENOTSUP;
6959
6960         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6961
6962         uint64_t feat_flags = dev_info.feature_flags;
6963
6964         if (op_mode == IN_PLACE) {
6965                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6966                         printf("Device doesn't support in-place scatter-gather "
6967                                         "in both input and output mbufs.\n");
6968                         return -ENOTSUP;
6969                 }
6970         } else {
6971                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6972                         printf("Device doesn't support out-of-place scatter-gather "
6973                                         "in both input and output mbufs.\n");
6974                         return -ENOTSUP;
6975                 }
6976                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6977                         printf("Device doesn't support digest encrypted.\n");
6978                         return -ENOTSUP;
6979                 }
6980         }
6981
6982         /* Create the session */
6983         if (verify)
6984                 retval = create_wireless_algo_cipher_auth_session(
6985                                 ts_params->valid_devs[0],
6986                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6987                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6988                                 tdata->auth_algo,
6989                                 tdata->cipher_algo,
6990                                 tdata->auth_key.data, tdata->auth_key.len,
6991                                 tdata->auth_iv.len, tdata->digest_enc.len,
6992                                 tdata->cipher_iv.len);
6993         else
6994                 retval = create_wireless_algo_auth_cipher_session(
6995                                 ts_params->valid_devs[0],
6996                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6997                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6998                                 tdata->auth_algo,
6999                                 tdata->cipher_algo,
7000                                 tdata->auth_key.data, tdata->auth_key.len,
7001                                 tdata->auth_iv.len, tdata->digest_enc.len,
7002                                 tdata->cipher_iv.len);
7003         if (retval < 0)
7004                 return retval;
7005
7006         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7007         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7008         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7009         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7010
7011         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7012                         ciphertext_pad_len, 15, 0);
7013         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7014                         "Failed to allocate input buffer in mempool");
7015
7016         if (op_mode == OUT_OF_PLACE) {
7017                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7018                                 plaintext_pad_len, 15, 0);
7019                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7020                                 "Failed to allocate output buffer in mempool");
7021         }
7022
7023         if (verify) {
7024                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7025                         tdata->ciphertext.data);
7026                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7027                                         ciphertext_len, buffer);
7028                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7029                         ciphertext_len);
7030         } else {
7031                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7032                         tdata->plaintext.data);
7033                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7034                                         plaintext_len, buffer);
7035                 debug_hexdump(stdout, "plaintext:", plaintext,
7036                         plaintext_len);
7037         }
7038         memset(buffer, 0, sizeof(buffer));
7039
7040         /* Create the operation */
7041         retval = create_wireless_algo_auth_cipher_operation(
7042                         tdata->digest_enc.data, tdata->digest_enc.len,
7043                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7044                         tdata->auth_iv.data, tdata->auth_iv.len,
7045                         (tdata->digest_enc.offset == 0 ?
7046                                 plaintext_pad_len
7047                                 : tdata->digest_enc.offset),
7048                         tdata->validCipherLen.len_bits,
7049                         tdata->cipher.offset_bits,
7050                         tdata->validAuthLen.len_bits,
7051                         tdata->auth.offset_bits,
7052                         op_mode, 1, verify);
7053
7054         if (retval < 0)
7055                 return retval;
7056
7057         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
7058                         ut_params->op);
7059
7060         /* Check if the op failed because the device doesn't */
7061         /* support this particular combination of algorithms */
7062         if (ut_params->op == NULL && ut_params->op->status ==
7063                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7064                 printf("Device doesn't support this mixed combination. "
7065                                 "Test Skipped.\n");
7066                 return -ENOTSUP;
7067         }
7068
7069         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7070
7071         ut_params->obuf = (op_mode == IN_PLACE ?
7072                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7073
7074         if (verify) {
7075                 if (ut_params->obuf)
7076                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7077                                         plaintext_len, buffer);
7078                 else
7079                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7080                                         plaintext_len, buffer);
7081
7082                 debug_hexdump(stdout, "plaintext:", plaintext,
7083                                 (tdata->plaintext.len_bits >> 3) -
7084                                 tdata->digest_enc.len);
7085                 debug_hexdump(stdout, "plaintext expected:",
7086                                 tdata->plaintext.data,
7087                                 (tdata->plaintext.len_bits >> 3) -
7088                                 tdata->digest_enc.len);
7089         } else {
7090                 if (ut_params->obuf)
7091                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7092                                         ciphertext_len, buffer);
7093                 else
7094                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7095                                         ciphertext_len, buffer);
7096
7097                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7098                         ciphertext_len);
7099                 debug_hexdump(stdout, "ciphertext expected:",
7100                         tdata->ciphertext.data,
7101                         tdata->ciphertext.len_bits >> 3);
7102
7103                 if (ut_params->obuf)
7104                         digest = rte_pktmbuf_read(ut_params->obuf,
7105                                         (tdata->digest_enc.offset == 0 ?
7106                                                 plaintext_pad_len :
7107                                                 tdata->digest_enc.offset),
7108                                         tdata->digest_enc.len, digest_buffer);
7109                 else
7110                         digest = rte_pktmbuf_read(ut_params->ibuf,
7111                                         (tdata->digest_enc.offset == 0 ?
7112                                                 plaintext_pad_len :
7113                                                 tdata->digest_enc.offset),
7114                                         tdata->digest_enc.len, digest_buffer);
7115
7116                 debug_hexdump(stdout, "digest:", digest,
7117                                 tdata->digest_enc.len);
7118                 debug_hexdump(stdout, "digest expected:",
7119                                 tdata->digest_enc.data, tdata->digest_enc.len);
7120         }
7121
7122         /* Validate obuf */
7123         if (verify) {
7124                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7125                                 plaintext,
7126                                 tdata->plaintext.data,
7127                                 tdata->plaintext.len_bits >> 3,
7128                                 "Plaintext data not as expected");
7129         } else {
7130                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7131                                 ciphertext,
7132                                 tdata->ciphertext.data,
7133                                 tdata->validDataLen.len_bits,
7134                                 "Ciphertext data not as expected");
7135                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7136                                 digest,
7137                                 tdata->digest_enc.data,
7138                                 tdata->digest_enc.len,
7139                                 "Generated auth tag not as expected");
7140         }
7141
7142         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7143                         "crypto op processing failed");
7144
7145         return 0;
7146 }
7147
7148 /** AUTH AES CMAC + CIPHER AES CTR */
7149
7150 static int
7151 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7152 {
7153         return test_mixed_auth_cipher(
7154                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7155 }
7156
7157 static int
7158 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7159 {
7160         return test_mixed_auth_cipher(
7161                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7162 }
7163
7164 static int
7165 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7166 {
7167         return test_mixed_auth_cipher_sgl(
7168                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7169 }
7170
7171 static int
7172 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7173 {
7174         return test_mixed_auth_cipher_sgl(
7175                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7176 }
7177
7178 static int
7179 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7180 {
7181         return test_mixed_auth_cipher(
7182                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7183 }
7184
7185 static int
7186 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7187 {
7188         return test_mixed_auth_cipher(
7189                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7190 }
7191
7192 static int
7193 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7194 {
7195         return test_mixed_auth_cipher_sgl(
7196                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7197 }
7198
7199 static int
7200 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7201 {
7202         return test_mixed_auth_cipher_sgl(
7203                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7204 }
7205
7206 /** MIXED AUTH + CIPHER */
7207
7208 static int
7209 test_auth_zuc_cipher_snow_test_case_1(void)
7210 {
7211         return test_mixed_auth_cipher(
7212                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7213 }
7214
7215 static int
7216 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7217 {
7218         return test_mixed_auth_cipher(
7219                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7220 }
7221
7222 static int
7223 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7224 {
7225         return test_mixed_auth_cipher(
7226                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7227 }
7228
7229 static int
7230 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7231 {
7232         return test_mixed_auth_cipher(
7233                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7234 }
7235
7236 static int
7237 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7238 {
7239         return test_mixed_auth_cipher(
7240                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7241 }
7242
7243 static int
7244 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7245 {
7246         return test_mixed_auth_cipher(
7247                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7248 }
7249
7250 static int
7251 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7252 {
7253         return test_mixed_auth_cipher(
7254                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7255 }
7256
7257 static int
7258 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7259 {
7260         return test_mixed_auth_cipher(
7261                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7262 }
7263
7264 static int
7265 test_auth_snow_cipher_zuc_test_case_1(void)
7266 {
7267         return test_mixed_auth_cipher(
7268                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7269 }
7270
7271 static int
7272 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7273 {
7274         return test_mixed_auth_cipher(
7275                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7276 }
7277
7278 static int
7279 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7280 {
7281         return test_mixed_auth_cipher(
7282                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7283 }
7284
7285 static int
7286 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7287 {
7288         return test_mixed_auth_cipher(
7289                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7290 }
7291
7292 static int
7293 test_auth_null_cipher_snow_test_case_1(void)
7294 {
7295         return test_mixed_auth_cipher(
7296                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7297 }
7298
7299 static int
7300 test_verify_auth_null_cipher_snow_test_case_1(void)
7301 {
7302         return test_mixed_auth_cipher(
7303                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7304 }
7305
7306 static int
7307 test_auth_null_cipher_zuc_test_case_1(void)
7308 {
7309         return test_mixed_auth_cipher(
7310                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7311 }
7312
7313 static int
7314 test_verify_auth_null_cipher_zuc_test_case_1(void)
7315 {
7316         return test_mixed_auth_cipher(
7317                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7318 }
7319
7320 static int
7321 test_auth_snow_cipher_null_test_case_1(void)
7322 {
7323         return test_mixed_auth_cipher(
7324                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7325 }
7326
7327 static int
7328 test_verify_auth_snow_cipher_null_test_case_1(void)
7329 {
7330         return test_mixed_auth_cipher(
7331                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7332 }
7333
7334 static int
7335 test_auth_zuc_cipher_null_test_case_1(void)
7336 {
7337         return test_mixed_auth_cipher(
7338                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7339 }
7340
7341 static int
7342 test_verify_auth_zuc_cipher_null_test_case_1(void)
7343 {
7344         return test_mixed_auth_cipher(
7345                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7346 }
7347
7348 static int
7349 test_auth_null_cipher_aes_ctr_test_case_1(void)
7350 {
7351         return test_mixed_auth_cipher(
7352                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7353 }
7354
7355 static int
7356 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7357 {
7358         return test_mixed_auth_cipher(
7359                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7360 }
7361
7362 static int
7363 test_auth_aes_cmac_cipher_null_test_case_1(void)
7364 {
7365         return test_mixed_auth_cipher(
7366                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7367 }
7368
7369 static int
7370 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7371 {
7372         return test_mixed_auth_cipher(
7373                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7374 }
7375
7376 /* ***** AEAD algorithm Tests ***** */
7377
7378 static int
7379 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7380                 enum rte_crypto_aead_operation op,
7381                 const uint8_t *key, const uint8_t key_len,
7382                 const uint16_t aad_len, const uint8_t auth_len,
7383                 uint8_t iv_len)
7384 {
7385         uint8_t aead_key[key_len];
7386
7387         struct crypto_testsuite_params *ts_params = &testsuite_params;
7388         struct crypto_unittest_params *ut_params = &unittest_params;
7389
7390         memcpy(aead_key, key, key_len);
7391
7392         /* Setup AEAD Parameters */
7393         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7394         ut_params->aead_xform.next = NULL;
7395         ut_params->aead_xform.aead.algo = algo;
7396         ut_params->aead_xform.aead.op = op;
7397         ut_params->aead_xform.aead.key.data = aead_key;
7398         ut_params->aead_xform.aead.key.length = key_len;
7399         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7400         ut_params->aead_xform.aead.iv.length = iv_len;
7401         ut_params->aead_xform.aead.digest_length = auth_len;
7402         ut_params->aead_xform.aead.aad_length = aad_len;
7403
7404         debug_hexdump(stdout, "key:", key, key_len);
7405
7406         /* Create Crypto session*/
7407         ut_params->sess = rte_cryptodev_sym_session_create(
7408                         ts_params->session_mpool);
7409
7410         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7411                         &ut_params->aead_xform,
7412                         ts_params->session_priv_mpool);
7413
7414         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7415
7416         return 0;
7417 }
7418
7419 static int
7420 create_aead_xform(struct rte_crypto_op *op,
7421                 enum rte_crypto_aead_algorithm algo,
7422                 enum rte_crypto_aead_operation aead_op,
7423                 uint8_t *key, const uint8_t key_len,
7424                 const uint8_t aad_len, const uint8_t auth_len,
7425                 uint8_t iv_len)
7426 {
7427         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7428                         "failed to allocate space for crypto transform");
7429
7430         struct rte_crypto_sym_op *sym_op = op->sym;
7431
7432         /* Setup AEAD Parameters */
7433         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7434         sym_op->xform->next = NULL;
7435         sym_op->xform->aead.algo = algo;
7436         sym_op->xform->aead.op = aead_op;
7437         sym_op->xform->aead.key.data = key;
7438         sym_op->xform->aead.key.length = key_len;
7439         sym_op->xform->aead.iv.offset = IV_OFFSET;
7440         sym_op->xform->aead.iv.length = iv_len;
7441         sym_op->xform->aead.digest_length = auth_len;
7442         sym_op->xform->aead.aad_length = aad_len;
7443
7444         debug_hexdump(stdout, "key:", key, key_len);
7445
7446         return 0;
7447 }
7448
7449 static int
7450 create_aead_operation(enum rte_crypto_aead_operation op,
7451                 const struct aead_test_data *tdata)
7452 {
7453         struct crypto_testsuite_params *ts_params = &testsuite_params;
7454         struct crypto_unittest_params *ut_params = &unittest_params;
7455
7456         uint8_t *plaintext, *ciphertext;
7457         unsigned int aad_pad_len, plaintext_pad_len;
7458
7459         /* Generate Crypto op data structure */
7460         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7461                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7462         TEST_ASSERT_NOT_NULL(ut_params->op,
7463                         "Failed to allocate symmetric crypto operation struct");
7464
7465         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7466
7467         /* Append aad data */
7468         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7469                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7470                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7471                                 aad_pad_len);
7472                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7473                                 "no room to append aad");
7474
7475                 sym_op->aead.aad.phys_addr =
7476                                 rte_pktmbuf_iova(ut_params->ibuf);
7477                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7478                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7479                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7480                         tdata->aad.len);
7481
7482                 /* Append IV at the end of the crypto operation*/
7483                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7484                                 uint8_t *, IV_OFFSET);
7485
7486                 /* Copy IV 1 byte after the IV pointer, according to the API */
7487                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7488                 debug_hexdump(stdout, "iv:", iv_ptr,
7489                         tdata->iv.len);
7490         } else {
7491                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7492                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7493                                 aad_pad_len);
7494                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7495                                 "no room to append aad");
7496
7497                 sym_op->aead.aad.phys_addr =
7498                                 rte_pktmbuf_iova(ut_params->ibuf);
7499                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7500                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7501                         tdata->aad.len);
7502
7503                 /* Append IV at the end of the crypto operation*/
7504                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7505                                 uint8_t *, IV_OFFSET);
7506
7507                 if (tdata->iv.len == 0) {
7508                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7509                         debug_hexdump(stdout, "iv:", iv_ptr,
7510                                 AES_GCM_J0_LENGTH);
7511                 } else {
7512                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7513                         debug_hexdump(stdout, "iv:", iv_ptr,
7514                                 tdata->iv.len);
7515                 }
7516         }
7517
7518         /* Append plaintext/ciphertext */
7519         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7520                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7521                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7522                                 plaintext_pad_len);
7523                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7524
7525                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7526                 debug_hexdump(stdout, "plaintext:", plaintext,
7527                                 tdata->plaintext.len);
7528
7529                 if (ut_params->obuf) {
7530                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7531                                         ut_params->obuf,
7532                                         plaintext_pad_len + aad_pad_len);
7533                         TEST_ASSERT_NOT_NULL(ciphertext,
7534                                         "no room to append ciphertext");
7535
7536                         memset(ciphertext + aad_pad_len, 0,
7537                                         tdata->ciphertext.len);
7538                 }
7539         } else {
7540                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7541                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7542                                 plaintext_pad_len);
7543                 TEST_ASSERT_NOT_NULL(ciphertext,
7544                                 "no room to append ciphertext");
7545
7546                 memcpy(ciphertext, tdata->ciphertext.data,
7547                                 tdata->ciphertext.len);
7548                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7549                                 tdata->ciphertext.len);
7550
7551                 if (ut_params->obuf) {
7552                         plaintext = (uint8_t *)rte_pktmbuf_append(
7553                                         ut_params->obuf,
7554                                         plaintext_pad_len + aad_pad_len);
7555                         TEST_ASSERT_NOT_NULL(plaintext,
7556                                         "no room to append plaintext");
7557
7558                         memset(plaintext + aad_pad_len, 0,
7559                                         tdata->plaintext.len);
7560                 }
7561         }
7562
7563         /* Append digest data */
7564         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7565                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7566                                 ut_params->obuf ? ut_params->obuf :
7567                                                 ut_params->ibuf,
7568                                                 tdata->auth_tag.len);
7569                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7570                                 "no room to append digest");
7571                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7572                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7573                                 ut_params->obuf ? ut_params->obuf :
7574                                                 ut_params->ibuf,
7575                                                 plaintext_pad_len +
7576                                                 aad_pad_len);
7577         } else {
7578                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7579                                 ut_params->ibuf, tdata->auth_tag.len);
7580                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7581                                 "no room to append digest");
7582                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7583                                 ut_params->ibuf,
7584                                 plaintext_pad_len + aad_pad_len);
7585
7586                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7587                         tdata->auth_tag.len);
7588                 debug_hexdump(stdout, "digest:",
7589                         sym_op->aead.digest.data,
7590                         tdata->auth_tag.len);
7591         }
7592
7593         sym_op->aead.data.length = tdata->plaintext.len;
7594         sym_op->aead.data.offset = aad_pad_len;
7595
7596         return 0;
7597 }
7598
7599 static int
7600 test_authenticated_encryption(const struct aead_test_data *tdata)
7601 {
7602         struct crypto_testsuite_params *ts_params = &testsuite_params;
7603         struct crypto_unittest_params *ut_params = &unittest_params;
7604
7605         int retval;
7606         uint8_t *ciphertext, *auth_tag;
7607         uint16_t plaintext_pad_len;
7608         uint32_t i;
7609         struct rte_cryptodev_info dev_info;
7610
7611         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7612         uint64_t feat_flags = dev_info.feature_flags;
7613
7614         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
7615                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
7616                 printf("Device doesn't support RAW data-path APIs.\n");
7617                 return -ENOTSUP;
7618         }
7619
7620         /* Verify the capabilities */
7621         struct rte_cryptodev_sym_capability_idx cap_idx;
7622         const struct rte_cryptodev_symmetric_capability *capability;
7623         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7624         cap_idx.algo.aead = tdata->algo;
7625         capability = rte_cryptodev_sym_capability_get(
7626                         ts_params->valid_devs[0], &cap_idx);
7627         if (capability == NULL)
7628                 return -ENOTSUP;
7629         if (rte_cryptodev_sym_capability_check_aead(
7630                         capability, tdata->key.len, tdata->auth_tag.len,
7631                         tdata->aad.len, tdata->iv.len))
7632                 return -ENOTSUP;
7633
7634         /* Create AEAD session */
7635         retval = create_aead_session(ts_params->valid_devs[0],
7636                         tdata->algo,
7637                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7638                         tdata->key.data, tdata->key.len,
7639                         tdata->aad.len, tdata->auth_tag.len,
7640                         tdata->iv.len);
7641         if (retval < 0)
7642                 return retval;
7643
7644         if (tdata->aad.len > MBUF_SIZE) {
7645                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7646                 /* Populate full size of add data */
7647                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7648                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7649         } else
7650                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7651
7652         /* clear mbuf payload */
7653         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7654                         rte_pktmbuf_tailroom(ut_params->ibuf));
7655
7656         /* Create AEAD operation */
7657         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7658         if (retval < 0)
7659                 return retval;
7660
7661         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7662
7663         ut_params->op->sym->m_src = ut_params->ibuf;
7664
7665         /* Process crypto operation */
7666         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7667                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7668         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7669                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
7670                                 ut_params->op, 0, 0, 0, 0);
7671         else
7672                 TEST_ASSERT_NOT_NULL(
7673                         process_crypto_request(ts_params->valid_devs[0],
7674                         ut_params->op), "failed to process sym crypto op");
7675
7676         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7677                         "crypto op processing failed");
7678
7679         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7680
7681         if (ut_params->op->sym->m_dst) {
7682                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7683                                 uint8_t *);
7684                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7685                                 uint8_t *, plaintext_pad_len);
7686         } else {
7687                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7688                                 uint8_t *,
7689                                 ut_params->op->sym->cipher.data.offset);
7690                 auth_tag = ciphertext + plaintext_pad_len;
7691         }
7692
7693         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7694         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7695
7696         /* Validate obuf */
7697         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7698                         ciphertext,
7699                         tdata->ciphertext.data,
7700                         tdata->ciphertext.len,
7701                         "Ciphertext data not as expected");
7702
7703         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7704                         auth_tag,
7705                         tdata->auth_tag.data,
7706                         tdata->auth_tag.len,
7707                         "Generated auth tag not as expected");
7708
7709         return 0;
7710
7711 }
7712
7713 #ifdef RTE_LIB_SECURITY
7714 static int
7715 security_proto_supported(enum rte_security_session_action_type action,
7716         enum rte_security_session_protocol proto)
7717 {
7718         struct crypto_testsuite_params *ts_params = &testsuite_params;
7719
7720         const struct rte_security_capability *capabilities;
7721         const struct rte_security_capability *capability;
7722         uint16_t i = 0;
7723
7724         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7725                                 rte_cryptodev_get_sec_ctx(
7726                                 ts_params->valid_devs[0]);
7727
7728
7729         capabilities = rte_security_capabilities_get(ctx);
7730
7731         if (capabilities == NULL)
7732                 return -ENOTSUP;
7733
7734         while ((capability = &capabilities[i++])->action !=
7735                         RTE_SECURITY_ACTION_TYPE_NONE) {
7736                 if (capability->action == action &&
7737                                 capability->protocol == proto)
7738                         return 0;
7739         }
7740
7741         return -ENOTSUP;
7742 }
7743
7744 /* Basic algorithm run function for async inplace mode.
7745  * Creates a session from input parameters and runs one operation
7746  * on input_vec. Checks the output of the crypto operation against
7747  * output_vec.
7748  */
7749 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
7750                            enum rte_crypto_auth_operation opa,
7751                            const uint8_t *input_vec, unsigned int input_vec_len,
7752                            const uint8_t *output_vec,
7753                            unsigned int output_vec_len,
7754                            enum rte_crypto_cipher_algorithm cipher_alg,
7755                            const uint8_t *cipher_key, uint32_t cipher_key_len,
7756                            enum rte_crypto_auth_algorithm auth_alg,
7757                            const uint8_t *auth_key, uint32_t auth_key_len,
7758                            uint8_t bearer, enum rte_security_pdcp_domain domain,
7759                            uint8_t packet_direction, uint8_t sn_size,
7760                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
7761 {
7762         struct crypto_testsuite_params *ts_params = &testsuite_params;
7763         struct crypto_unittest_params *ut_params = &unittest_params;
7764         uint8_t *plaintext;
7765         int ret = TEST_SUCCESS;
7766         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7767                                 rte_cryptodev_get_sec_ctx(
7768                                 ts_params->valid_devs[0]);
7769
7770         /* Verify the capabilities */
7771         struct rte_security_capability_idx sec_cap_idx;
7772
7773         sec_cap_idx.action = ut_params->type;
7774         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7775         sec_cap_idx.pdcp.domain = domain;
7776         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7777                 return -ENOTSUP;
7778
7779         /* Generate test mbuf data */
7780         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7781
7782         /* clear mbuf payload */
7783         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7784                         rte_pktmbuf_tailroom(ut_params->ibuf));
7785
7786         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7787                                                   input_vec_len);
7788         memcpy(plaintext, input_vec, input_vec_len);
7789
7790         /* Out of place support */
7791         if (oop) {
7792                 /*
7793                  * For out-op-place we need to alloc another mbuf
7794                  */
7795                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7796                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7797         }
7798
7799         /* Setup Cipher Parameters */
7800         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7801         ut_params->cipher_xform.cipher.algo = cipher_alg;
7802         ut_params->cipher_xform.cipher.op = opc;
7803         ut_params->cipher_xform.cipher.key.data = cipher_key;
7804         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
7805         ut_params->cipher_xform.cipher.iv.length =
7806                                 packet_direction ? 4 : 0;
7807         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7808
7809         /* Setup HMAC Parameters if ICV header is required */
7810         if (auth_alg != 0) {
7811                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7812                 ut_params->auth_xform.next = NULL;
7813                 ut_params->auth_xform.auth.algo = auth_alg;
7814                 ut_params->auth_xform.auth.op = opa;
7815                 ut_params->auth_xform.auth.key.data = auth_key;
7816                 ut_params->auth_xform.auth.key.length = auth_key_len;
7817
7818                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7819         } else {
7820                 ut_params->cipher_xform.next = NULL;
7821         }
7822
7823         struct rte_security_session_conf sess_conf = {
7824                 .action_type = ut_params->type,
7825                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7826                 {.pdcp = {
7827                         .bearer = bearer,
7828                         .domain = domain,
7829                         .pkt_dir = packet_direction,
7830                         .sn_size = sn_size,
7831                         .hfn = packet_direction ? 0 : hfn,
7832                         /**
7833                          * hfn can be set as pdcp_test_hfn[i]
7834                          * if hfn_ovrd is not set. Here, PDCP
7835                          * packet direction is just used to
7836                          * run half of the cases with session
7837                          * HFN and other half with per packet
7838                          * HFN.
7839                          */
7840                         .hfn_threshold = hfn_threshold,
7841                         .hfn_ovrd = packet_direction ? 1 : 0,
7842                         .sdap_enabled = sdap,
7843                 } },
7844                 .crypto_xform = &ut_params->cipher_xform
7845         };
7846
7847         /* Create security session */
7848         ut_params->sec_session = rte_security_session_create(ctx,
7849                                 &sess_conf, ts_params->session_mpool,
7850                                 ts_params->session_priv_mpool);
7851
7852         if (!ut_params->sec_session) {
7853                 printf("TestCase %s()-%d line %d failed %s: ",
7854                         __func__, i, __LINE__, "Failed to allocate session");
7855                 ret = TEST_FAILED;
7856                 goto on_err;
7857         }
7858
7859         /* Generate crypto op data structure */
7860         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7861                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7862         if (!ut_params->op) {
7863                 printf("TestCase %s()-%d line %d failed %s: ",
7864                         __func__, i, __LINE__,
7865                         "Failed to allocate symmetric crypto operation struct");
7866                 ret = TEST_FAILED;
7867                 goto on_err;
7868         }
7869
7870         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
7871                                         uint32_t *, IV_OFFSET);
7872         *per_pkt_hfn = packet_direction ? hfn : 0;
7873
7874         rte_security_attach_session(ut_params->op, ut_params->sec_session);
7875
7876         /* set crypto operation source mbuf */
7877         ut_params->op->sym->m_src = ut_params->ibuf;
7878         if (oop)
7879                 ut_params->op->sym->m_dst = ut_params->obuf;
7880
7881         /* Process crypto operation */
7882         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7883                 == NULL) {
7884                 printf("TestCase %s()-%d line %d failed %s: ",
7885                         __func__, i, __LINE__,
7886                         "failed to process sym crypto op");
7887                 ret = TEST_FAILED;
7888                 goto on_err;
7889         }
7890
7891         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7892                 printf("TestCase %s()-%d line %d failed %s: ",
7893                         __func__, i, __LINE__, "crypto op processing failed");
7894                 ret = TEST_FAILED;
7895                 goto on_err;
7896         }
7897
7898         /* Validate obuf */
7899         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7900                         uint8_t *);
7901         if (oop) {
7902                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7903                                 uint8_t *);
7904         }
7905
7906         if (memcmp(ciphertext, output_vec, output_vec_len)) {
7907                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7908                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7909                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7910                 ret = TEST_FAILED;
7911                 goto on_err;
7912         }
7913
7914 on_err:
7915         rte_crypto_op_free(ut_params->op);
7916         ut_params->op = NULL;
7917
7918         if (ut_params->sec_session)
7919                 rte_security_session_destroy(ctx, ut_params->sec_session);
7920         ut_params->sec_session = NULL;
7921
7922         rte_pktmbuf_free(ut_params->ibuf);
7923         ut_params->ibuf = NULL;
7924         if (oop) {
7925                 rte_pktmbuf_free(ut_params->obuf);
7926                 ut_params->obuf = NULL;
7927         }
7928
7929         return ret;
7930 }
7931
7932 static int
7933 test_pdcp_proto_SGL(int i, int oop,
7934         enum rte_crypto_cipher_operation opc,
7935         enum rte_crypto_auth_operation opa,
7936         uint8_t *input_vec,
7937         unsigned int input_vec_len,
7938         uint8_t *output_vec,
7939         unsigned int output_vec_len,
7940         uint32_t fragsz,
7941         uint32_t fragsz_oop)
7942 {
7943         struct crypto_testsuite_params *ts_params = &testsuite_params;
7944         struct crypto_unittest_params *ut_params = &unittest_params;
7945         uint8_t *plaintext;
7946         struct rte_mbuf *buf, *buf_oop = NULL;
7947         int ret = TEST_SUCCESS;
7948         int to_trn = 0;
7949         int to_trn_tbl[16];
7950         int segs = 1;
7951         unsigned int trn_data = 0;
7952         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7953                                 rte_cryptodev_get_sec_ctx(
7954                                 ts_params->valid_devs[0]);
7955
7956         /* Verify the capabilities */
7957         struct rte_security_capability_idx sec_cap_idx;
7958
7959         sec_cap_idx.action = ut_params->type;
7960         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7961         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7962         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7963                 return -ENOTSUP;
7964
7965         if (fragsz > input_vec_len)
7966                 fragsz = input_vec_len;
7967
7968         uint16_t plaintext_len = fragsz;
7969         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7970
7971         if (fragsz_oop > output_vec_len)
7972                 frag_size_oop = output_vec_len;
7973
7974         int ecx = 0;
7975         if (input_vec_len % fragsz != 0) {
7976                 if (input_vec_len / fragsz + 1 > 16)
7977                         return 1;
7978         } else if (input_vec_len / fragsz > 16)
7979                 return 1;
7980
7981         /* Out of place support */
7982         if (oop) {
7983                 /*
7984                  * For out-op-place we need to alloc another mbuf
7985                  */
7986                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7987                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7988                 buf_oop = ut_params->obuf;
7989         }
7990
7991         /* Generate test mbuf data */
7992         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7993
7994         /* clear mbuf payload */
7995         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7996                         rte_pktmbuf_tailroom(ut_params->ibuf));
7997
7998         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7999                                                   plaintext_len);
8000         memcpy(plaintext, input_vec, plaintext_len);
8001         trn_data += plaintext_len;
8002
8003         buf = ut_params->ibuf;
8004
8005         /*
8006          * Loop until no more fragments
8007          */
8008
8009         while (trn_data < input_vec_len) {
8010                 ++segs;
8011                 to_trn = (input_vec_len - trn_data < fragsz) ?
8012                                 (input_vec_len - trn_data) : fragsz;
8013
8014                 to_trn_tbl[ecx++] = to_trn;
8015
8016                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8017                 buf = buf->next;
8018
8019                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8020                                 rte_pktmbuf_tailroom(buf));
8021
8022                 /* OOP */
8023                 if (oop && !fragsz_oop) {
8024                         buf_oop->next =
8025                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8026                         buf_oop = buf_oop->next;
8027                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8028                                         0, rte_pktmbuf_tailroom(buf_oop));
8029                         rte_pktmbuf_append(buf_oop, to_trn);
8030                 }
8031
8032                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8033                                 to_trn);
8034
8035                 memcpy(plaintext, input_vec + trn_data, to_trn);
8036                 trn_data += to_trn;
8037         }
8038
8039         ut_params->ibuf->nb_segs = segs;
8040
8041         segs = 1;
8042         if (fragsz_oop && oop) {
8043                 to_trn = 0;
8044                 ecx = 0;
8045
8046                 trn_data = frag_size_oop;
8047                 while (trn_data < output_vec_len) {
8048                         ++segs;
8049                         to_trn =
8050                                 (output_vec_len - trn_data <
8051                                                 frag_size_oop) ?
8052                                 (output_vec_len - trn_data) :
8053                                                 frag_size_oop;
8054
8055                         to_trn_tbl[ecx++] = to_trn;
8056
8057                         buf_oop->next =
8058                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8059                         buf_oop = buf_oop->next;
8060                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8061                                         0, rte_pktmbuf_tailroom(buf_oop));
8062                         rte_pktmbuf_append(buf_oop, to_trn);
8063
8064                         trn_data += to_trn;
8065                 }
8066                 ut_params->obuf->nb_segs = segs;
8067         }
8068
8069         /* Setup Cipher Parameters */
8070         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8071         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8072         ut_params->cipher_xform.cipher.op = opc;
8073         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8074         ut_params->cipher_xform.cipher.key.length =
8075                                         pdcp_test_params[i].cipher_key_len;
8076         ut_params->cipher_xform.cipher.iv.length = 0;
8077
8078         /* Setup HMAC Parameters if ICV header is required */
8079         if (pdcp_test_params[i].auth_alg != 0) {
8080                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8081                 ut_params->auth_xform.next = NULL;
8082                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8083                 ut_params->auth_xform.auth.op = opa;
8084                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8085                 ut_params->auth_xform.auth.key.length =
8086                                         pdcp_test_params[i].auth_key_len;
8087
8088                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8089         } else {
8090                 ut_params->cipher_xform.next = NULL;
8091         }
8092
8093         struct rte_security_session_conf sess_conf = {
8094                 .action_type = ut_params->type,
8095                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8096                 {.pdcp = {
8097                         .bearer = pdcp_test_bearer[i],
8098                         .domain = pdcp_test_params[i].domain,
8099                         .pkt_dir = pdcp_test_packet_direction[i],
8100                         .sn_size = pdcp_test_data_sn_size[i],
8101                         .hfn = pdcp_test_hfn[i],
8102                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8103                         .hfn_ovrd = 0,
8104                 } },
8105                 .crypto_xform = &ut_params->cipher_xform
8106         };
8107
8108         /* Create security session */
8109         ut_params->sec_session = rte_security_session_create(ctx,
8110                                 &sess_conf, ts_params->session_mpool,
8111                                 ts_params->session_priv_mpool);
8112
8113         if (!ut_params->sec_session) {
8114                 printf("TestCase %s()-%d line %d failed %s: ",
8115                         __func__, i, __LINE__, "Failed to allocate session");
8116                 ret = TEST_FAILED;
8117                 goto on_err;
8118         }
8119
8120         /* Generate crypto op data structure */
8121         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8122                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8123         if (!ut_params->op) {
8124                 printf("TestCase %s()-%d line %d failed %s: ",
8125                         __func__, i, __LINE__,
8126                         "Failed to allocate symmetric crypto operation struct");
8127                 ret = TEST_FAILED;
8128                 goto on_err;
8129         }
8130
8131         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8132
8133         /* set crypto operation source mbuf */
8134         ut_params->op->sym->m_src = ut_params->ibuf;
8135         if (oop)
8136                 ut_params->op->sym->m_dst = ut_params->obuf;
8137
8138         /* Process crypto operation */
8139         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8140                 == NULL) {
8141                 printf("TestCase %s()-%d line %d failed %s: ",
8142                         __func__, i, __LINE__,
8143                         "failed to process sym crypto op");
8144                 ret = TEST_FAILED;
8145                 goto on_err;
8146         }
8147
8148         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8149                 printf("TestCase %s()-%d line %d failed %s: ",
8150                         __func__, i, __LINE__, "crypto op processing failed");
8151                 ret = TEST_FAILED;
8152                 goto on_err;
8153         }
8154
8155         /* Validate obuf */
8156         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8157                         uint8_t *);
8158         if (oop) {
8159                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8160                                 uint8_t *);
8161         }
8162         if (fragsz_oop)
8163                 fragsz = frag_size_oop;
8164         if (memcmp(ciphertext, output_vec, fragsz)) {
8165                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8166                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8167                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8168                 ret = TEST_FAILED;
8169                 goto on_err;
8170         }
8171
8172         buf = ut_params->op->sym->m_src->next;
8173         if (oop)
8174                 buf = ut_params->op->sym->m_dst->next;
8175
8176         unsigned int off = fragsz;
8177
8178         ecx = 0;
8179         while (buf) {
8180                 ciphertext = rte_pktmbuf_mtod(buf,
8181                                 uint8_t *);
8182                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8183                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8184                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8185                         rte_hexdump(stdout, "reference", output_vec + off,
8186                                         to_trn_tbl[ecx]);
8187                         ret = TEST_FAILED;
8188                         goto on_err;
8189                 }
8190                 off += to_trn_tbl[ecx++];
8191                 buf = buf->next;
8192         }
8193 on_err:
8194         rte_crypto_op_free(ut_params->op);
8195         ut_params->op = NULL;
8196
8197         if (ut_params->sec_session)
8198                 rte_security_session_destroy(ctx, ut_params->sec_session);
8199         ut_params->sec_session = NULL;
8200
8201         rte_pktmbuf_free(ut_params->ibuf);
8202         ut_params->ibuf = NULL;
8203         if (oop) {
8204                 rte_pktmbuf_free(ut_params->obuf);
8205                 ut_params->obuf = NULL;
8206         }
8207
8208         return ret;
8209 }
8210
8211 int
8212 test_pdcp_proto_cplane_encap(int i)
8213 {
8214         return test_pdcp_proto(
8215                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8216                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8217                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8218                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8219                 pdcp_test_params[i].cipher_key_len,
8220                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8221                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8222                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8223                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8224                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8225 }
8226
8227 int
8228 test_pdcp_proto_uplane_encap(int i)
8229 {
8230         return test_pdcp_proto(
8231                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8232                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8233                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8234                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8235                 pdcp_test_params[i].cipher_key_len,
8236                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8237                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8238                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8239                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8240                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8241 }
8242
8243 int
8244 test_pdcp_proto_uplane_encap_with_int(int i)
8245 {
8246         return test_pdcp_proto(
8247                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8248                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8249                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8250                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8251                 pdcp_test_params[i].cipher_key_len,
8252                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8253                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8254                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8255                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8256                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8257 }
8258
8259 int
8260 test_pdcp_proto_cplane_decap(int i)
8261 {
8262         return test_pdcp_proto(
8263                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8264                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8265                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8266                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8267                 pdcp_test_params[i].cipher_key_len,
8268                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8269                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8270                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8271                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8272                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8273 }
8274
8275 int
8276 test_pdcp_proto_uplane_decap(int i)
8277 {
8278         return test_pdcp_proto(
8279                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8280                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8281                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8282                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8283                 pdcp_test_params[i].cipher_key_len,
8284                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8285                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8286                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8287                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8288                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8289 }
8290
8291 int
8292 test_pdcp_proto_uplane_decap_with_int(int i)
8293 {
8294         return test_pdcp_proto(
8295                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8296                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8297                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8298                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8299                 pdcp_test_params[i].cipher_key_len,
8300                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8301                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8302                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8303                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8304                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8305 }
8306
8307 static int
8308 test_PDCP_PROTO_SGL_in_place_32B(void)
8309 {
8310         /* i can be used for running any PDCP case
8311          * In this case it is uplane 12-bit AES-SNOW DL encap
8312          */
8313         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8314         return test_pdcp_proto_SGL(i, IN_PLACE,
8315                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8316                         RTE_CRYPTO_AUTH_OP_GENERATE,
8317                         pdcp_test_data_in[i],
8318                         pdcp_test_data_in_len[i],
8319                         pdcp_test_data_out[i],
8320                         pdcp_test_data_in_len[i]+4,
8321                         32, 0);
8322 }
8323 static int
8324 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8325 {
8326         /* i can be used for running any PDCP case
8327          * In this case it is uplane 18-bit NULL-NULL DL encap
8328          */
8329         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8330         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8331                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8332                         RTE_CRYPTO_AUTH_OP_GENERATE,
8333                         pdcp_test_data_in[i],
8334                         pdcp_test_data_in_len[i],
8335                         pdcp_test_data_out[i],
8336                         pdcp_test_data_in_len[i]+4,
8337                         32, 128);
8338 }
8339 static int
8340 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8341 {
8342         /* i can be used for running any PDCP case
8343          * In this case it is uplane 18-bit AES DL encap
8344          */
8345         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8346                         + DOWNLINK;
8347         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8348                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8349                         RTE_CRYPTO_AUTH_OP_GENERATE,
8350                         pdcp_test_data_in[i],
8351                         pdcp_test_data_in_len[i],
8352                         pdcp_test_data_out[i],
8353                         pdcp_test_data_in_len[i],
8354                         32, 40);
8355 }
8356 static int
8357 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8358 {
8359         /* i can be used for running any PDCP case
8360          * In this case it is cplane 12-bit AES-ZUC DL encap
8361          */
8362         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8363         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8364                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8365                         RTE_CRYPTO_AUTH_OP_GENERATE,
8366                         pdcp_test_data_in[i],
8367                         pdcp_test_data_in_len[i],
8368                         pdcp_test_data_out[i],
8369                         pdcp_test_data_in_len[i]+4,
8370                         128, 32);
8371 }
8372
8373 static int
8374 test_PDCP_SDAP_PROTO_encap_all(void)
8375 {
8376         int i = 0, size = 0;
8377         int err, all_err = TEST_SUCCESS;
8378         const struct pdcp_sdap_test *cur_test;
8379
8380         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8381
8382         for (i = 0; i < size; i++) {
8383                 cur_test = &list_pdcp_sdap_tests[i];
8384                 err = test_pdcp_proto(
8385                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8386                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8387                         cur_test->in_len, cur_test->data_out,
8388                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8389                         cur_test->param.cipher_alg, cur_test->cipher_key,
8390                         cur_test->param.cipher_key_len,
8391                         cur_test->param.auth_alg,
8392                         cur_test->auth_key, cur_test->param.auth_key_len,
8393                         cur_test->bearer, cur_test->param.domain,
8394                         cur_test->packet_direction, cur_test->sn_size,
8395                         cur_test->hfn,
8396                         cur_test->hfn_threshold, SDAP_ENABLED);
8397                 if (err) {
8398                         printf("\t%d) %s: Encapsulation failed\n",
8399                                         cur_test->test_idx,
8400                                         cur_test->param.name);
8401                         err = TEST_FAILED;
8402                 } else {
8403                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8404                                         cur_test->param.name);
8405                         err = TEST_SUCCESS;
8406                 }
8407                 all_err += err;
8408         }
8409
8410         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8411
8412         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8413 }
8414
8415 static int
8416 test_PDCP_SDAP_PROTO_decap_all(void)
8417 {
8418         int i = 0, size = 0;
8419         int err, all_err = TEST_SUCCESS;
8420         const struct pdcp_sdap_test *cur_test;
8421
8422         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8423
8424         for (i = 0; i < size; i++) {
8425                 cur_test = &list_pdcp_sdap_tests[i];
8426                 err = test_pdcp_proto(
8427                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8428                         RTE_CRYPTO_AUTH_OP_VERIFY,
8429                         cur_test->data_out,
8430                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8431                         cur_test->data_in, cur_test->in_len,
8432                         cur_test->param.cipher_alg,
8433                         cur_test->cipher_key, cur_test->param.cipher_key_len,
8434                         cur_test->param.auth_alg, cur_test->auth_key,
8435                         cur_test->param.auth_key_len, cur_test->bearer,
8436                         cur_test->param.domain, cur_test->packet_direction,
8437                         cur_test->sn_size, cur_test->hfn,
8438                         cur_test->hfn_threshold, SDAP_ENABLED);
8439                 if (err) {
8440                         printf("\t%d) %s: Decapsulation failed\n",
8441                                         cur_test->test_idx,
8442                                         cur_test->param.name);
8443                         err = TEST_FAILED;
8444                 } else {
8445                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8446                                         cur_test->param.name);
8447                         err = TEST_SUCCESS;
8448                 }
8449                 all_err += err;
8450         }
8451
8452         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8453
8454         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8455 }
8456
8457 static int
8458 test_PDCP_PROTO_all(void)
8459 {
8460         struct crypto_testsuite_params *ts_params = &testsuite_params;
8461         struct crypto_unittest_params *ut_params = &unittest_params;
8462         struct rte_cryptodev_info dev_info;
8463         int status;
8464
8465         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8466         uint64_t feat_flags = dev_info.feature_flags;
8467
8468         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8469                 return -ENOTSUP;
8470
8471         /* Set action type */
8472         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8473                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8474                 gbl_action_type;
8475
8476         if (security_proto_supported(ut_params->type,
8477                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
8478                 return -ENOTSUP;
8479
8480         status = test_PDCP_PROTO_cplane_encap_all();
8481         status += test_PDCP_PROTO_cplane_decap_all();
8482         status += test_PDCP_PROTO_uplane_encap_all();
8483         status += test_PDCP_PROTO_uplane_decap_all();
8484         status += test_PDCP_PROTO_SGL_in_place_32B();
8485         status += test_PDCP_PROTO_SGL_oop_32B_128B();
8486         status += test_PDCP_PROTO_SGL_oop_32B_40B();
8487         status += test_PDCP_PROTO_SGL_oop_128B_32B();
8488         status += test_PDCP_SDAP_PROTO_encap_all();
8489         status += test_PDCP_SDAP_PROTO_decap_all();
8490
8491         if (status)
8492                 return TEST_FAILED;
8493         else
8494                 return TEST_SUCCESS;
8495 }
8496
8497 static int
8498 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
8499 {
8500         struct crypto_testsuite_params *ts_params = &testsuite_params;
8501         struct crypto_unittest_params *ut_params = &unittest_params;
8502         uint8_t *plaintext, *ciphertext;
8503         uint8_t *iv_ptr;
8504         int32_t cipher_len, crc_len;
8505         uint32_t crc_data_len;
8506         int ret = TEST_SUCCESS;
8507
8508         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8509                                         rte_cryptodev_get_sec_ctx(
8510                                                 ts_params->valid_devs[0]);
8511
8512         /* Verify the capabilities */
8513         struct rte_security_capability_idx sec_cap_idx;
8514         const struct rte_security_capability *sec_cap;
8515         const struct rte_cryptodev_capabilities *crypto_cap;
8516         const struct rte_cryptodev_symmetric_capability *sym_cap;
8517         int j = 0;
8518
8519         sec_cap_idx.action = ut_params->type;
8520         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8521         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
8522
8523         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8524         if (sec_cap == NULL)
8525                 return -ENOTSUP;
8526
8527         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8528                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8529                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8530                                 crypto_cap->sym.xform_type ==
8531                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8532                                 crypto_cap->sym.cipher.algo ==
8533                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8534                         sym_cap = &crypto_cap->sym;
8535                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8536                                                 d_td->key.len,
8537                                                 d_td->iv.len) == 0)
8538                                 break;
8539                 }
8540         }
8541
8542         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8543                 return -ENOTSUP;
8544
8545         /* Setup source mbuf payload */
8546         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8547         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8548                         rte_pktmbuf_tailroom(ut_params->ibuf));
8549
8550         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8551                         d_td->ciphertext.len);
8552
8553         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
8554
8555         /* Setup cipher session parameters */
8556         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8557         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8558         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
8559         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8560         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8561         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8562         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8563         ut_params->cipher_xform.next = NULL;
8564
8565         /* Setup DOCSIS session parameters */
8566         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
8567
8568         struct rte_security_session_conf sess_conf = {
8569                 .action_type = ut_params->type,
8570                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8571                 .docsis = ut_params->docsis_xform,
8572                 .crypto_xform = &ut_params->cipher_xform,
8573         };
8574
8575         /* Create security session */
8576         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8577                                         ts_params->session_mpool,
8578                                         ts_params->session_priv_mpool);
8579
8580         if (!ut_params->sec_session) {
8581                 printf("TestCase %s(%d) line %d: %s\n",
8582                         __func__, i, __LINE__, "failed to allocate session");
8583                 ret = TEST_FAILED;
8584                 goto on_err;
8585         }
8586
8587         /* Generate crypto op data structure */
8588         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8589                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8590         if (!ut_params->op) {
8591                 printf("TestCase %s(%d) line %d: %s\n",
8592                         __func__, i, __LINE__,
8593                         "failed to allocate symmetric crypto operation");
8594                 ret = TEST_FAILED;
8595                 goto on_err;
8596         }
8597
8598         /* Setup CRC operation parameters */
8599         crc_len = d_td->ciphertext.no_crc == false ?
8600                         (d_td->ciphertext.len -
8601                                 d_td->ciphertext.crc_offset -
8602                                 RTE_ETHER_CRC_LEN) :
8603                         0;
8604         crc_len = crc_len > 0 ? crc_len : 0;
8605         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
8606         ut_params->op->sym->auth.data.length = crc_len;
8607         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
8608
8609         /* Setup cipher operation parameters */
8610         cipher_len = d_td->ciphertext.no_cipher == false ?
8611                         (d_td->ciphertext.len -
8612                                 d_td->ciphertext.cipher_offset) :
8613                         0;
8614         cipher_len = cipher_len > 0 ? cipher_len : 0;
8615         ut_params->op->sym->cipher.data.length = cipher_len;
8616         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
8617
8618         /* Setup cipher IV */
8619         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8620         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8621
8622         /* Attach session to operation */
8623         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8624
8625         /* Set crypto operation mbufs */
8626         ut_params->op->sym->m_src = ut_params->ibuf;
8627         ut_params->op->sym->m_dst = NULL;
8628
8629         /* Process crypto operation */
8630         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8631                         NULL) {
8632                 printf("TestCase %s(%d) line %d: %s\n",
8633                         __func__, i, __LINE__,
8634                         "failed to process security crypto op");
8635                 ret = TEST_FAILED;
8636                 goto on_err;
8637         }
8638
8639         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8640                 printf("TestCase %s(%d) line %d: %s\n",
8641                         __func__, i, __LINE__, "crypto op processing failed");
8642                 ret = TEST_FAILED;
8643                 goto on_err;
8644         }
8645
8646         /* Validate plaintext */
8647         plaintext = ciphertext;
8648
8649         if (memcmp(plaintext, d_td->plaintext.data,
8650                         d_td->plaintext.len - crc_data_len)) {
8651                 printf("TestCase %s(%d) line %d: %s\n",
8652                         __func__, i, __LINE__, "plaintext not as expected\n");
8653                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
8654                                 d_td->plaintext.len);
8655                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
8656                 ret = TEST_FAILED;
8657                 goto on_err;
8658         }
8659
8660 on_err:
8661         rte_crypto_op_free(ut_params->op);
8662         ut_params->op = NULL;
8663
8664         if (ut_params->sec_session)
8665                 rte_security_session_destroy(ctx, ut_params->sec_session);
8666         ut_params->sec_session = NULL;
8667
8668         rte_pktmbuf_free(ut_params->ibuf);
8669         ut_params->ibuf = NULL;
8670
8671         return ret;
8672 }
8673
8674 static int
8675 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
8676 {
8677         struct crypto_testsuite_params *ts_params = &testsuite_params;
8678         struct crypto_unittest_params *ut_params = &unittest_params;
8679         uint8_t *plaintext, *ciphertext;
8680         uint8_t *iv_ptr;
8681         int32_t cipher_len, crc_len;
8682         int ret = TEST_SUCCESS;
8683
8684         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8685                                         rte_cryptodev_get_sec_ctx(
8686                                                 ts_params->valid_devs[0]);
8687
8688         /* Verify the capabilities */
8689         struct rte_security_capability_idx sec_cap_idx;
8690         const struct rte_security_capability *sec_cap;
8691         const struct rte_cryptodev_capabilities *crypto_cap;
8692         const struct rte_cryptodev_symmetric_capability *sym_cap;
8693         int j = 0;
8694
8695         sec_cap_idx.action = ut_params->type;
8696         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8697         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8698
8699         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8700         if (sec_cap == NULL)
8701                 return -ENOTSUP;
8702
8703         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8704                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8705                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8706                                 crypto_cap->sym.xform_type ==
8707                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8708                                 crypto_cap->sym.cipher.algo ==
8709                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8710                         sym_cap = &crypto_cap->sym;
8711                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8712                                                 d_td->key.len,
8713                                                 d_td->iv.len) == 0)
8714                                 break;
8715                 }
8716         }
8717
8718         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8719                 return -ENOTSUP;
8720
8721         /* Setup source mbuf payload */
8722         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8723         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8724                         rte_pktmbuf_tailroom(ut_params->ibuf));
8725
8726         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8727                         d_td->plaintext.len);
8728
8729         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
8730
8731         /* Setup cipher session parameters */
8732         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8733         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8734         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8735         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8736         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8737         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8738         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8739         ut_params->cipher_xform.next = NULL;
8740
8741         /* Setup DOCSIS session parameters */
8742         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8743
8744         struct rte_security_session_conf sess_conf = {
8745                 .action_type = ut_params->type,
8746                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8747                 .docsis = ut_params->docsis_xform,
8748                 .crypto_xform = &ut_params->cipher_xform,
8749         };
8750
8751         /* Create security session */
8752         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8753                                         ts_params->session_mpool,
8754                                         ts_params->session_priv_mpool);
8755
8756         if (!ut_params->sec_session) {
8757                 printf("TestCase %s(%d) line %d: %s\n",
8758                         __func__, i, __LINE__, "failed to allocate session");
8759                 ret = TEST_FAILED;
8760                 goto on_err;
8761         }
8762
8763         /* Generate crypto op data structure */
8764         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8765                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8766         if (!ut_params->op) {
8767                 printf("TestCase %s(%d) line %d: %s\n",
8768                         __func__, i, __LINE__,
8769                         "failed to allocate security crypto operation");
8770                 ret = TEST_FAILED;
8771                 goto on_err;
8772         }
8773
8774         /* Setup CRC operation parameters */
8775         crc_len = d_td->plaintext.no_crc == false ?
8776                         (d_td->plaintext.len -
8777                                 d_td->plaintext.crc_offset -
8778                                 RTE_ETHER_CRC_LEN) :
8779                         0;
8780         crc_len = crc_len > 0 ? crc_len : 0;
8781         ut_params->op->sym->auth.data.length = crc_len;
8782         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
8783
8784         /* Setup cipher operation parameters */
8785         cipher_len = d_td->plaintext.no_cipher == false ?
8786                         (d_td->plaintext.len -
8787                                 d_td->plaintext.cipher_offset) :
8788                         0;
8789         cipher_len = cipher_len > 0 ? cipher_len : 0;
8790         ut_params->op->sym->cipher.data.length = cipher_len;
8791         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
8792
8793         /* Setup cipher IV */
8794         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8795         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8796
8797         /* Attach session to operation */
8798         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8799
8800         /* Set crypto operation mbufs */
8801         ut_params->op->sym->m_src = ut_params->ibuf;
8802         ut_params->op->sym->m_dst = NULL;
8803
8804         /* Process crypto operation */
8805         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8806                         NULL) {
8807                 printf("TestCase %s(%d) line %d: %s\n",
8808                         __func__, i, __LINE__,
8809                         "failed to process security crypto op");
8810                 ret = TEST_FAILED;
8811                 goto on_err;
8812         }
8813
8814         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8815                 printf("TestCase %s(%d) line %d: %s\n",
8816                         __func__, i, __LINE__, "crypto op processing failed");
8817                 ret = TEST_FAILED;
8818                 goto on_err;
8819         }
8820
8821         /* Validate ciphertext */
8822         ciphertext = plaintext;
8823
8824         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
8825                 printf("TestCase %s(%d) line %d: %s\n",
8826                         __func__, i, __LINE__, "ciphertext not as expected\n");
8827                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
8828                                 d_td->ciphertext.len);
8829                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
8830                 ret = TEST_FAILED;
8831                 goto on_err;
8832         }
8833
8834 on_err:
8835         rte_crypto_op_free(ut_params->op);
8836         ut_params->op = NULL;
8837
8838         if (ut_params->sec_session)
8839                 rte_security_session_destroy(ctx, ut_params->sec_session);
8840         ut_params->sec_session = NULL;
8841
8842         rte_pktmbuf_free(ut_params->ibuf);
8843         ut_params->ibuf = NULL;
8844
8845         return ret;
8846 }
8847
8848 #define TEST_DOCSIS_COUNT(func) do {                    \
8849         int ret = func;                                 \
8850         if (ret == TEST_SUCCESS)  {                     \
8851                 printf("\t%2d)", n++);                  \
8852                 printf("+++++ PASSED:" #func"\n");      \
8853                 p++;                                    \
8854         } else if (ret == -ENOTSUP) {                   \
8855                 printf("\t%2d)", n++);                  \
8856                 printf("~~~~~ UNSUPP:" #func"\n");      \
8857                 u++;                                    \
8858         } else {                                        \
8859                 printf("\t%2d)", n++);                  \
8860                 printf("----- FAILED:" #func"\n");      \
8861                 f++;                                    \
8862         }                                               \
8863 } while (0)
8864
8865 static int
8866 test_DOCSIS_PROTO_uplink_all(void)
8867 {
8868         int p = 0, u = 0, f = 0, n = 0;
8869
8870         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
8871         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
8872         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
8873         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
8874         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
8875         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
8876         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
8877         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
8878         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
8879         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
8880         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
8881         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
8882         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
8883         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
8884         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
8885         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
8886         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
8887         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
8888         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
8889         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
8890         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
8891         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
8892         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
8893         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
8894         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
8895         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
8896
8897         if (f)
8898                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8899                         __func__, p, n, u);
8900
8901         return f;
8902 };
8903
8904 static int
8905 test_DOCSIS_PROTO_downlink_all(void)
8906 {
8907         int p = 0, u = 0, f = 0, n = 0;
8908
8909         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
8910         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
8911         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
8912         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
8913         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
8914         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
8915         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
8916         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
8917         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
8918         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
8919         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
8920         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
8921         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
8922         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
8923         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
8924         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
8925         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
8926         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
8927         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
8928         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
8929         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
8930         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
8931         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
8932         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
8933         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
8934         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
8935
8936         if (f)
8937                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8938                         __func__, p, n, u);
8939
8940         return f;
8941 };
8942
8943 static int
8944 test_DOCSIS_PROTO_all(void)
8945 {
8946         struct crypto_testsuite_params *ts_params = &testsuite_params;
8947         struct crypto_unittest_params *ut_params = &unittest_params;
8948         struct rte_cryptodev_info dev_info;
8949         int status;
8950
8951         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8952         uint64_t feat_flags = dev_info.feature_flags;
8953
8954         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8955                 return -ENOTSUP;
8956
8957         /* Set action type */
8958         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8959                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8960                 gbl_action_type;
8961
8962         if (security_proto_supported(ut_params->type,
8963                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
8964                 return -ENOTSUP;
8965
8966         status = test_DOCSIS_PROTO_uplink_all();
8967         status += test_DOCSIS_PROTO_downlink_all();
8968
8969         if (status)
8970                 return TEST_FAILED;
8971         else
8972                 return TEST_SUCCESS;
8973 }
8974 #endif
8975
8976 static int
8977 test_AES_GCM_authenticated_encryption_test_case_1(void)
8978 {
8979         return test_authenticated_encryption(&gcm_test_case_1);
8980 }
8981
8982 static int
8983 test_AES_GCM_authenticated_encryption_test_case_2(void)
8984 {
8985         return test_authenticated_encryption(&gcm_test_case_2);
8986 }
8987
8988 static int
8989 test_AES_GCM_authenticated_encryption_test_case_3(void)
8990 {
8991         return test_authenticated_encryption(&gcm_test_case_3);
8992 }
8993
8994 static int
8995 test_AES_GCM_authenticated_encryption_test_case_4(void)
8996 {
8997         return test_authenticated_encryption(&gcm_test_case_4);
8998 }
8999
9000 static int
9001 test_AES_GCM_authenticated_encryption_test_case_5(void)
9002 {
9003         return test_authenticated_encryption(&gcm_test_case_5);
9004 }
9005
9006 static int
9007 test_AES_GCM_authenticated_encryption_test_case_6(void)
9008 {
9009         return test_authenticated_encryption(&gcm_test_case_6);
9010 }
9011
9012 static int
9013 test_AES_GCM_authenticated_encryption_test_case_7(void)
9014 {
9015         return test_authenticated_encryption(&gcm_test_case_7);
9016 }
9017
9018 static int
9019 test_AES_GCM_authenticated_encryption_test_case_8(void)
9020 {
9021         return test_authenticated_encryption(&gcm_test_case_8);
9022 }
9023
9024 static int
9025 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9026 {
9027         return test_authenticated_encryption(&gcm_J0_test_case_1);
9028 }
9029
9030 static int
9031 test_AES_GCM_auth_encryption_test_case_192_1(void)
9032 {
9033         return test_authenticated_encryption(&gcm_test_case_192_1);
9034 }
9035
9036 static int
9037 test_AES_GCM_auth_encryption_test_case_192_2(void)
9038 {
9039         return test_authenticated_encryption(&gcm_test_case_192_2);
9040 }
9041
9042 static int
9043 test_AES_GCM_auth_encryption_test_case_192_3(void)
9044 {
9045         return test_authenticated_encryption(&gcm_test_case_192_3);
9046 }
9047
9048 static int
9049 test_AES_GCM_auth_encryption_test_case_192_4(void)
9050 {
9051         return test_authenticated_encryption(&gcm_test_case_192_4);
9052 }
9053
9054 static int
9055 test_AES_GCM_auth_encryption_test_case_192_5(void)
9056 {
9057         return test_authenticated_encryption(&gcm_test_case_192_5);
9058 }
9059
9060 static int
9061 test_AES_GCM_auth_encryption_test_case_192_6(void)
9062 {
9063         return test_authenticated_encryption(&gcm_test_case_192_6);
9064 }
9065
9066 static int
9067 test_AES_GCM_auth_encryption_test_case_192_7(void)
9068 {
9069         return test_authenticated_encryption(&gcm_test_case_192_7);
9070 }
9071
9072 static int
9073 test_AES_GCM_auth_encryption_test_case_256_1(void)
9074 {
9075         return test_authenticated_encryption(&gcm_test_case_256_1);
9076 }
9077
9078 static int
9079 test_AES_GCM_auth_encryption_test_case_256_2(void)
9080 {
9081         return test_authenticated_encryption(&gcm_test_case_256_2);
9082 }
9083
9084 static int
9085 test_AES_GCM_auth_encryption_test_case_256_3(void)
9086 {
9087         return test_authenticated_encryption(&gcm_test_case_256_3);
9088 }
9089
9090 static int
9091 test_AES_GCM_auth_encryption_test_case_256_4(void)
9092 {
9093         return test_authenticated_encryption(&gcm_test_case_256_4);
9094 }
9095
9096 static int
9097 test_AES_GCM_auth_encryption_test_case_256_5(void)
9098 {
9099         return test_authenticated_encryption(&gcm_test_case_256_5);
9100 }
9101
9102 static int
9103 test_AES_GCM_auth_encryption_test_case_256_6(void)
9104 {
9105         return test_authenticated_encryption(&gcm_test_case_256_6);
9106 }
9107
9108 static int
9109 test_AES_GCM_auth_encryption_test_case_256_7(void)
9110 {
9111         return test_authenticated_encryption(&gcm_test_case_256_7);
9112 }
9113
9114 static int
9115 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9116 {
9117         return test_authenticated_encryption(&gcm_test_case_aad_1);
9118 }
9119
9120 static int
9121 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9122 {
9123         return test_authenticated_encryption(&gcm_test_case_aad_2);
9124 }
9125
9126 static int
9127 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9128 {
9129         struct aead_test_data tdata;
9130         int res;
9131
9132         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9133         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9134         tdata.iv.data[0] += 1;
9135         res = test_authenticated_encryption(&tdata);
9136         if (res == -ENOTSUP)
9137                 return res;
9138         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9139         return TEST_SUCCESS;
9140 }
9141
9142 static int
9143 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9144 {
9145         struct aead_test_data tdata;
9146         int res;
9147
9148         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9149         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9150         tdata.plaintext.data[0] += 1;
9151         res = test_authenticated_encryption(&tdata);
9152         if (res == -ENOTSUP)
9153                 return res;
9154         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9155         return TEST_SUCCESS;
9156 }
9157
9158 static int
9159 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9160 {
9161         struct aead_test_data tdata;
9162         int res;
9163
9164         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9165         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9166         tdata.ciphertext.data[0] += 1;
9167         res = test_authenticated_encryption(&tdata);
9168         if (res == -ENOTSUP)
9169                 return res;
9170         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9171         return TEST_SUCCESS;
9172 }
9173
9174 static int
9175 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9176 {
9177         struct aead_test_data tdata;
9178         int res;
9179
9180         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9181         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9182         tdata.aad.len += 1;
9183         res = test_authenticated_encryption(&tdata);
9184         if (res == -ENOTSUP)
9185                 return res;
9186         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9187         return TEST_SUCCESS;
9188 }
9189
9190 static int
9191 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9192 {
9193         struct aead_test_data tdata;
9194         uint8_t aad[gcm_test_case_7.aad.len];
9195         int res;
9196
9197         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9198         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9199         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9200         aad[0] += 1;
9201         tdata.aad.data = aad;
9202         res = test_authenticated_encryption(&tdata);
9203         if (res == -ENOTSUP)
9204                 return res;
9205         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9206         return TEST_SUCCESS;
9207 }
9208
9209 static int
9210 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9211 {
9212         struct aead_test_data tdata;
9213         int res;
9214
9215         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9216         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9217         tdata.auth_tag.data[0] += 1;
9218         res = test_authenticated_encryption(&tdata);
9219         if (res == -ENOTSUP)
9220                 return res;
9221         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9222         return TEST_SUCCESS;
9223 }
9224
9225 static int
9226 test_authenticated_decryption(const struct aead_test_data *tdata)
9227 {
9228         struct crypto_testsuite_params *ts_params = &testsuite_params;
9229         struct crypto_unittest_params *ut_params = &unittest_params;
9230
9231         int retval;
9232         uint8_t *plaintext;
9233         uint32_t i;
9234         struct rte_cryptodev_info dev_info;
9235
9236         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9237         uint64_t feat_flags = dev_info.feature_flags;
9238
9239         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9240                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9241                 printf("Device doesn't support RAW data-path APIs.\n");
9242                 return -ENOTSUP;
9243         }
9244
9245         /* Verify the capabilities */
9246         struct rte_cryptodev_sym_capability_idx cap_idx;
9247         const struct rte_cryptodev_symmetric_capability *capability;
9248         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9249         cap_idx.algo.aead = tdata->algo;
9250         capability = rte_cryptodev_sym_capability_get(
9251                         ts_params->valid_devs[0], &cap_idx);
9252         if (capability == NULL)
9253                 return -ENOTSUP;
9254         if (rte_cryptodev_sym_capability_check_aead(
9255                         capability, tdata->key.len, tdata->auth_tag.len,
9256                         tdata->aad.len, tdata->iv.len))
9257                 return -ENOTSUP;
9258
9259         /* Create AEAD session */
9260         retval = create_aead_session(ts_params->valid_devs[0],
9261                         tdata->algo,
9262                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9263                         tdata->key.data, tdata->key.len,
9264                         tdata->aad.len, tdata->auth_tag.len,
9265                         tdata->iv.len);
9266         if (retval < 0)
9267                 return retval;
9268
9269         /* alloc mbuf and set payload */
9270         if (tdata->aad.len > MBUF_SIZE) {
9271                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9272                 /* Populate full size of add data */
9273                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9274                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9275         } else
9276                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9277
9278         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9279                         rte_pktmbuf_tailroom(ut_params->ibuf));
9280
9281         /* Create AEAD operation */
9282         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9283         if (retval < 0)
9284                 return retval;
9285
9286         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9287
9288         ut_params->op->sym->m_src = ut_params->ibuf;
9289
9290         /* Process crypto operation */
9291         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9292                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9293         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9294                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9295                                 ut_params->op, 0, 0, 0, 0);
9296         else
9297                 TEST_ASSERT_NOT_NULL(
9298                         process_crypto_request(ts_params->valid_devs[0],
9299                         ut_params->op), "failed to process sym crypto op");
9300
9301         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9302                         "crypto op processing failed");
9303
9304         if (ut_params->op->sym->m_dst)
9305                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
9306                                 uint8_t *);
9307         else
9308                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
9309                                 uint8_t *,
9310                                 ut_params->op->sym->cipher.data.offset);
9311
9312         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9313
9314         /* Validate obuf */
9315         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9316                         plaintext,
9317                         tdata->plaintext.data,
9318                         tdata->plaintext.len,
9319                         "Plaintext data not as expected");
9320
9321         TEST_ASSERT_EQUAL(ut_params->op->status,
9322                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9323                         "Authentication failed");
9324
9325         return 0;
9326 }
9327
9328 static int
9329 test_AES_GCM_authenticated_decryption_test_case_1(void)
9330 {
9331         return test_authenticated_decryption(&gcm_test_case_1);
9332 }
9333
9334 static int
9335 test_AES_GCM_authenticated_decryption_test_case_2(void)
9336 {
9337         return test_authenticated_decryption(&gcm_test_case_2);
9338 }
9339
9340 static int
9341 test_AES_GCM_authenticated_decryption_test_case_3(void)
9342 {
9343         return test_authenticated_decryption(&gcm_test_case_3);
9344 }
9345
9346 static int
9347 test_AES_GCM_authenticated_decryption_test_case_4(void)
9348 {
9349         return test_authenticated_decryption(&gcm_test_case_4);
9350 }
9351
9352 static int
9353 test_AES_GCM_authenticated_decryption_test_case_5(void)
9354 {
9355         return test_authenticated_decryption(&gcm_test_case_5);
9356 }
9357
9358 static int
9359 test_AES_GCM_authenticated_decryption_test_case_6(void)
9360 {
9361         return test_authenticated_decryption(&gcm_test_case_6);
9362 }
9363
9364 static int
9365 test_AES_GCM_authenticated_decryption_test_case_7(void)
9366 {
9367         return test_authenticated_decryption(&gcm_test_case_7);
9368 }
9369
9370 static int
9371 test_AES_GCM_authenticated_decryption_test_case_8(void)
9372 {
9373         return test_authenticated_decryption(&gcm_test_case_8);
9374 }
9375
9376 static int
9377 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
9378 {
9379         return test_authenticated_decryption(&gcm_J0_test_case_1);
9380 }
9381
9382 static int
9383 test_AES_GCM_auth_decryption_test_case_192_1(void)
9384 {
9385         return test_authenticated_decryption(&gcm_test_case_192_1);
9386 }
9387
9388 static int
9389 test_AES_GCM_auth_decryption_test_case_192_2(void)
9390 {
9391         return test_authenticated_decryption(&gcm_test_case_192_2);
9392 }
9393
9394 static int
9395 test_AES_GCM_auth_decryption_test_case_192_3(void)
9396 {
9397         return test_authenticated_decryption(&gcm_test_case_192_3);
9398 }
9399
9400 static int
9401 test_AES_GCM_auth_decryption_test_case_192_4(void)
9402 {
9403         return test_authenticated_decryption(&gcm_test_case_192_4);
9404 }
9405
9406 static int
9407 test_AES_GCM_auth_decryption_test_case_192_5(void)
9408 {
9409         return test_authenticated_decryption(&gcm_test_case_192_5);
9410 }
9411
9412 static int
9413 test_AES_GCM_auth_decryption_test_case_192_6(void)
9414 {
9415         return test_authenticated_decryption(&gcm_test_case_192_6);
9416 }
9417
9418 static int
9419 test_AES_GCM_auth_decryption_test_case_192_7(void)
9420 {
9421         return test_authenticated_decryption(&gcm_test_case_192_7);
9422 }
9423
9424 static int
9425 test_AES_GCM_auth_decryption_test_case_256_1(void)
9426 {
9427         return test_authenticated_decryption(&gcm_test_case_256_1);
9428 }
9429
9430 static int
9431 test_AES_GCM_auth_decryption_test_case_256_2(void)
9432 {
9433         return test_authenticated_decryption(&gcm_test_case_256_2);
9434 }
9435
9436 static int
9437 test_AES_GCM_auth_decryption_test_case_256_3(void)
9438 {
9439         return test_authenticated_decryption(&gcm_test_case_256_3);
9440 }
9441
9442 static int
9443 test_AES_GCM_auth_decryption_test_case_256_4(void)
9444 {
9445         return test_authenticated_decryption(&gcm_test_case_256_4);
9446 }
9447
9448 static int
9449 test_AES_GCM_auth_decryption_test_case_256_5(void)
9450 {
9451         return test_authenticated_decryption(&gcm_test_case_256_5);
9452 }
9453
9454 static int
9455 test_AES_GCM_auth_decryption_test_case_256_6(void)
9456 {
9457         return test_authenticated_decryption(&gcm_test_case_256_6);
9458 }
9459
9460 static int
9461 test_AES_GCM_auth_decryption_test_case_256_7(void)
9462 {
9463         return test_authenticated_decryption(&gcm_test_case_256_7);
9464 }
9465
9466 static int
9467 test_AES_GCM_auth_decryption_test_case_aad_1(void)
9468 {
9469         return test_authenticated_decryption(&gcm_test_case_aad_1);
9470 }
9471
9472 static int
9473 test_AES_GCM_auth_decryption_test_case_aad_2(void)
9474 {
9475         return test_authenticated_decryption(&gcm_test_case_aad_2);
9476 }
9477
9478 static int
9479 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
9480 {
9481         struct aead_test_data tdata;
9482         int res;
9483
9484         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9485         tdata.iv.data[0] += 1;
9486         res = test_authenticated_decryption(&tdata);
9487         if (res == -ENOTSUP)
9488                 return res;
9489         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9490         return TEST_SUCCESS;
9491 }
9492
9493 static int
9494 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
9495 {
9496         struct aead_test_data tdata;
9497         int res;
9498
9499         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9500         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9501         tdata.plaintext.data[0] += 1;
9502         res = test_authenticated_decryption(&tdata);
9503         if (res == -ENOTSUP)
9504                 return res;
9505         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9506         return TEST_SUCCESS;
9507 }
9508
9509 static int
9510 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
9511 {
9512         struct aead_test_data tdata;
9513         int res;
9514
9515         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9516         tdata.ciphertext.data[0] += 1;
9517         res = test_authenticated_decryption(&tdata);
9518         if (res == -ENOTSUP)
9519                 return res;
9520         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9521         return TEST_SUCCESS;
9522 }
9523
9524 static int
9525 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
9526 {
9527         struct aead_test_data tdata;
9528         int res;
9529
9530         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9531         tdata.aad.len += 1;
9532         res = test_authenticated_decryption(&tdata);
9533         if (res == -ENOTSUP)
9534                 return res;
9535         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9536         return TEST_SUCCESS;
9537 }
9538
9539 static int
9540 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9541 {
9542         struct aead_test_data tdata;
9543         uint8_t aad[gcm_test_case_7.aad.len];
9544         int res;
9545
9546         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9547         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9548         aad[0] += 1;
9549         tdata.aad.data = aad;
9550         res = test_authenticated_decryption(&tdata);
9551         if (res == -ENOTSUP)
9552                 return res;
9553         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9554         return TEST_SUCCESS;
9555 }
9556
9557 static int
9558 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9559 {
9560         struct aead_test_data tdata;
9561         int res;
9562
9563         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9564         tdata.auth_tag.data[0] += 1;
9565         res = test_authenticated_decryption(&tdata);
9566         if (res == -ENOTSUP)
9567                 return res;
9568         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9569         return TEST_SUCCESS;
9570 }
9571
9572 static int
9573 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9574 {
9575         struct crypto_testsuite_params *ts_params = &testsuite_params;
9576         struct crypto_unittest_params *ut_params = &unittest_params;
9577
9578         int retval;
9579         uint8_t *ciphertext, *auth_tag;
9580         uint16_t plaintext_pad_len;
9581
9582         /* Verify the capabilities */
9583         struct rte_cryptodev_sym_capability_idx cap_idx;
9584         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9585         cap_idx.algo.aead = tdata->algo;
9586         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9587                         &cap_idx) == NULL)
9588                 return -ENOTSUP;
9589
9590         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9591                 return -ENOTSUP;
9592
9593         /* not supported with CPU crypto */
9594         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9595                 return -ENOTSUP;
9596
9597         /* Create AEAD session */
9598         retval = create_aead_session(ts_params->valid_devs[0],
9599                         tdata->algo,
9600                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9601                         tdata->key.data, tdata->key.len,
9602                         tdata->aad.len, tdata->auth_tag.len,
9603                         tdata->iv.len);
9604         if (retval < 0)
9605                 return retval;
9606
9607         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9608         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9609
9610         /* clear mbuf payload */
9611         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9612                         rte_pktmbuf_tailroom(ut_params->ibuf));
9613         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9614                         rte_pktmbuf_tailroom(ut_params->obuf));
9615
9616         /* Create AEAD operation */
9617         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9618         if (retval < 0)
9619                 return retval;
9620
9621         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9622
9623         ut_params->op->sym->m_src = ut_params->ibuf;
9624         ut_params->op->sym->m_dst = ut_params->obuf;
9625
9626         /* Process crypto operation */
9627         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9628                         ut_params->op), "failed to process sym crypto op");
9629
9630         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9631                         "crypto op processing failed");
9632
9633         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9634
9635         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9636                         ut_params->op->sym->cipher.data.offset);
9637         auth_tag = ciphertext + plaintext_pad_len;
9638
9639         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9640         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9641
9642         /* Validate obuf */
9643         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9644                         ciphertext,
9645                         tdata->ciphertext.data,
9646                         tdata->ciphertext.len,
9647                         "Ciphertext data not as expected");
9648
9649         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9650                         auth_tag,
9651                         tdata->auth_tag.data,
9652                         tdata->auth_tag.len,
9653                         "Generated auth tag not as expected");
9654
9655         return 0;
9656
9657 }
9658
9659 static int
9660 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
9661 {
9662         return test_authenticated_encryption_oop(&gcm_test_case_5);
9663 }
9664
9665 static int
9666 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
9667 {
9668         struct crypto_testsuite_params *ts_params = &testsuite_params;
9669         struct crypto_unittest_params *ut_params = &unittest_params;
9670
9671         int retval;
9672         uint8_t *plaintext;
9673
9674         /* Verify the capabilities */
9675         struct rte_cryptodev_sym_capability_idx cap_idx;
9676         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9677         cap_idx.algo.aead = tdata->algo;
9678         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9679                         &cap_idx) == NULL)
9680                 return -ENOTSUP;
9681
9682         /* not supported with CPU crypto and raw data-path APIs*/
9683         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
9684                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
9685                 return -ENOTSUP;
9686
9687         /* Create AEAD session */
9688         retval = create_aead_session(ts_params->valid_devs[0],
9689                         tdata->algo,
9690                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9691                         tdata->key.data, tdata->key.len,
9692                         tdata->aad.len, tdata->auth_tag.len,
9693                         tdata->iv.len);
9694         if (retval < 0)
9695                 return retval;
9696
9697         /* alloc mbuf and set payload */
9698         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9699         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9700
9701         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9702                         rte_pktmbuf_tailroom(ut_params->ibuf));
9703         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9704                         rte_pktmbuf_tailroom(ut_params->obuf));
9705
9706         /* Create AEAD operation */
9707         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9708         if (retval < 0)
9709                 return retval;
9710
9711         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9712
9713         ut_params->op->sym->m_src = ut_params->ibuf;
9714         ut_params->op->sym->m_dst = ut_params->obuf;
9715
9716         /* Process crypto operation */
9717         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9718                         ut_params->op), "failed to process sym crypto op");
9719
9720         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9721                         "crypto op processing failed");
9722
9723         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9724                         ut_params->op->sym->cipher.data.offset);
9725
9726         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9727
9728         /* Validate obuf */
9729         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9730                         plaintext,
9731                         tdata->plaintext.data,
9732                         tdata->plaintext.len,
9733                         "Plaintext data not as expected");
9734
9735         TEST_ASSERT_EQUAL(ut_params->op->status,
9736                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9737                         "Authentication failed");
9738         return 0;
9739 }
9740
9741 static int
9742 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
9743 {
9744         return test_authenticated_decryption_oop(&gcm_test_case_5);
9745 }
9746
9747 static int
9748 test_authenticated_encryption_sessionless(
9749                 const struct aead_test_data *tdata)
9750 {
9751         struct crypto_testsuite_params *ts_params = &testsuite_params;
9752         struct crypto_unittest_params *ut_params = &unittest_params;
9753
9754         int retval;
9755         uint8_t *ciphertext, *auth_tag;
9756         uint16_t plaintext_pad_len;
9757         uint8_t key[tdata->key.len + 1];
9758         struct rte_cryptodev_info dev_info;
9759
9760         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9761         uint64_t feat_flags = dev_info.feature_flags;
9762
9763         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9764                 printf("Device doesn't support Sessionless ops.\n");
9765                 return -ENOTSUP;
9766         }
9767
9768         /* not supported with CPU crypto */
9769         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9770                 return -ENOTSUP;
9771
9772         /* Verify the capabilities */
9773         struct rte_cryptodev_sym_capability_idx cap_idx;
9774         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9775         cap_idx.algo.aead = tdata->algo;
9776         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9777                         &cap_idx) == NULL)
9778                 return -ENOTSUP;
9779
9780         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9781
9782         /* clear mbuf payload */
9783         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9784                         rte_pktmbuf_tailroom(ut_params->ibuf));
9785
9786         /* Create AEAD operation */
9787         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9788         if (retval < 0)
9789                 return retval;
9790
9791         /* Create GCM xform */
9792         memcpy(key, tdata->key.data, tdata->key.len);
9793         retval = create_aead_xform(ut_params->op,
9794                         tdata->algo,
9795                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9796                         key, tdata->key.len,
9797                         tdata->aad.len, tdata->auth_tag.len,
9798                         tdata->iv.len);
9799         if (retval < 0)
9800                 return retval;
9801
9802         ut_params->op->sym->m_src = ut_params->ibuf;
9803
9804         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9805                         RTE_CRYPTO_OP_SESSIONLESS,
9806                         "crypto op session type not sessionless");
9807
9808         /* Process crypto operation */
9809         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9810                         ut_params->op), "failed to process sym crypto op");
9811
9812         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9813
9814         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9815                         "crypto op status not success");
9816
9817         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9818
9819         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9820                         ut_params->op->sym->cipher.data.offset);
9821         auth_tag = ciphertext + plaintext_pad_len;
9822
9823         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9824         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9825
9826         /* Validate obuf */
9827         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9828                         ciphertext,
9829                         tdata->ciphertext.data,
9830                         tdata->ciphertext.len,
9831                         "Ciphertext data not as expected");
9832
9833         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9834                         auth_tag,
9835                         tdata->auth_tag.data,
9836                         tdata->auth_tag.len,
9837                         "Generated auth tag not as expected");
9838
9839         return 0;
9840
9841 }
9842
9843 static int
9844 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9845 {
9846         return test_authenticated_encryption_sessionless(
9847                         &gcm_test_case_5);
9848 }
9849
9850 static int
9851 test_authenticated_decryption_sessionless(
9852                 const struct aead_test_data *tdata)
9853 {
9854         struct crypto_testsuite_params *ts_params = &testsuite_params;
9855         struct crypto_unittest_params *ut_params = &unittest_params;
9856
9857         int retval;
9858         uint8_t *plaintext;
9859         uint8_t key[tdata->key.len + 1];
9860         struct rte_cryptodev_info dev_info;
9861
9862         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9863         uint64_t feat_flags = dev_info.feature_flags;
9864
9865         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9866                 printf("Device doesn't support Sessionless ops.\n");
9867                 return -ENOTSUP;
9868         }
9869
9870         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9871                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9872                 printf("Device doesn't support RAW data-path APIs.\n");
9873                 return -ENOTSUP;
9874         }
9875
9876         /* not supported with CPU crypto */
9877         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9878                 return -ENOTSUP;
9879
9880         /* Verify the capabilities */
9881         struct rte_cryptodev_sym_capability_idx cap_idx;
9882         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9883         cap_idx.algo.aead = tdata->algo;
9884         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9885                         &cap_idx) == NULL)
9886                 return -ENOTSUP;
9887
9888         /* alloc mbuf and set payload */
9889         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9890
9891         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9892                         rte_pktmbuf_tailroom(ut_params->ibuf));
9893
9894         /* Create AEAD operation */
9895         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9896         if (retval < 0)
9897                 return retval;
9898
9899         /* Create AEAD xform */
9900         memcpy(key, tdata->key.data, tdata->key.len);
9901         retval = create_aead_xform(ut_params->op,
9902                         tdata->algo,
9903                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9904                         key, tdata->key.len,
9905                         tdata->aad.len, tdata->auth_tag.len,
9906                         tdata->iv.len);
9907         if (retval < 0)
9908                 return retval;
9909
9910         ut_params->op->sym->m_src = ut_params->ibuf;
9911
9912         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9913                         RTE_CRYPTO_OP_SESSIONLESS,
9914                         "crypto op session type not sessionless");
9915
9916         /* Process crypto operation */
9917         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9918                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9919                                 ut_params->op, 0, 0, 0, 0);
9920         else
9921                 TEST_ASSERT_NOT_NULL(process_crypto_request(
9922                         ts_params->valid_devs[0], ut_params->op),
9923                                 "failed to process sym crypto op");
9924
9925         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9926
9927         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9928                         "crypto op status not success");
9929
9930         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9931                         ut_params->op->sym->cipher.data.offset);
9932
9933         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9934
9935         /* Validate obuf */
9936         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9937                         plaintext,
9938                         tdata->plaintext.data,
9939                         tdata->plaintext.len,
9940                         "Plaintext data not as expected");
9941
9942         TEST_ASSERT_EQUAL(ut_params->op->status,
9943                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9944                         "Authentication failed");
9945         return 0;
9946 }
9947
9948 static int
9949 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9950 {
9951         return test_authenticated_decryption_sessionless(
9952                         &gcm_test_case_5);
9953 }
9954
9955 static int
9956 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9957 {
9958         return test_authenticated_encryption(&ccm_test_case_128_1);
9959 }
9960
9961 static int
9962 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9963 {
9964         return test_authenticated_encryption(&ccm_test_case_128_2);
9965 }
9966
9967 static int
9968 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9969 {
9970         return test_authenticated_encryption(&ccm_test_case_128_3);
9971 }
9972
9973 static int
9974 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9975 {
9976         return test_authenticated_decryption(&ccm_test_case_128_1);
9977 }
9978
9979 static int
9980 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9981 {
9982         return test_authenticated_decryption(&ccm_test_case_128_2);
9983 }
9984
9985 static int
9986 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9987 {
9988         return test_authenticated_decryption(&ccm_test_case_128_3);
9989 }
9990
9991 static int
9992 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9993 {
9994         return test_authenticated_encryption(&ccm_test_case_192_1);
9995 }
9996
9997 static int
9998 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9999 {
10000         return test_authenticated_encryption(&ccm_test_case_192_2);
10001 }
10002
10003 static int
10004 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10005 {
10006         return test_authenticated_encryption(&ccm_test_case_192_3);
10007 }
10008
10009 static int
10010 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10011 {
10012         return test_authenticated_decryption(&ccm_test_case_192_1);
10013 }
10014
10015 static int
10016 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10017 {
10018         return test_authenticated_decryption(&ccm_test_case_192_2);
10019 }
10020
10021 static int
10022 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10023 {
10024         return test_authenticated_decryption(&ccm_test_case_192_3);
10025 }
10026
10027 static int
10028 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10029 {
10030         return test_authenticated_encryption(&ccm_test_case_256_1);
10031 }
10032
10033 static int
10034 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10035 {
10036         return test_authenticated_encryption(&ccm_test_case_256_2);
10037 }
10038
10039 static int
10040 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10041 {
10042         return test_authenticated_encryption(&ccm_test_case_256_3);
10043 }
10044
10045 static int
10046 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10047 {
10048         return test_authenticated_decryption(&ccm_test_case_256_1);
10049 }
10050
10051 static int
10052 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10053 {
10054         return test_authenticated_decryption(&ccm_test_case_256_2);
10055 }
10056
10057 static int
10058 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10059 {
10060         return test_authenticated_decryption(&ccm_test_case_256_3);
10061 }
10062
10063 static int
10064 test_stats(void)
10065 {
10066         struct crypto_testsuite_params *ts_params = &testsuite_params;
10067         struct rte_cryptodev_stats stats;
10068
10069         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10070                 return -ENOTSUP;
10071
10072         /* Verify the capabilities */
10073         struct rte_cryptodev_sym_capability_idx cap_idx;
10074         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10075         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10076         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10077                         &cap_idx) == NULL)
10078                 return -ENOTSUP;
10079         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10080         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10081         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10082                         &cap_idx) == NULL)
10083                 return -ENOTSUP;
10084
10085         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10086                         == -ENOTSUP)
10087                 return -ENOTSUP;
10088
10089         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10090         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10091                         &stats) == -ENODEV),
10092                 "rte_cryptodev_stats_get invalid dev failed");
10093         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10094                 "rte_cryptodev_stats_get invalid Param failed");
10095
10096         /* Test expected values */
10097         test_AES_CBC_HMAC_SHA1_encrypt_digest();
10098         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10099                         &stats),
10100                 "rte_cryptodev_stats_get failed");
10101         TEST_ASSERT((stats.enqueued_count == 1),
10102                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10103         TEST_ASSERT((stats.dequeued_count == 1),
10104                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10105         TEST_ASSERT((stats.enqueue_err_count == 0),
10106                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10107         TEST_ASSERT((stats.dequeue_err_count == 0),
10108                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10109
10110         /* invalid device but should ignore and not reset device stats*/
10111         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10112         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10113                         &stats),
10114                 "rte_cryptodev_stats_get failed");
10115         TEST_ASSERT((stats.enqueued_count == 1),
10116                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10117
10118         /* check that a valid reset clears stats */
10119         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10120         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10121                         &stats),
10122                                           "rte_cryptodev_stats_get failed");
10123         TEST_ASSERT((stats.enqueued_count == 0),
10124                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10125         TEST_ASSERT((stats.dequeued_count == 0),
10126                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10127
10128         return TEST_SUCCESS;
10129 }
10130
10131 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10132                                    struct crypto_unittest_params *ut_params,
10133                                    enum rte_crypto_auth_operation op,
10134                                    const struct HMAC_MD5_vector *test_case)
10135 {
10136         uint8_t key[64];
10137
10138         memcpy(key, test_case->key.data, test_case->key.len);
10139
10140         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10141         ut_params->auth_xform.next = NULL;
10142         ut_params->auth_xform.auth.op = op;
10143
10144         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10145
10146         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10147         ut_params->auth_xform.auth.key.length = test_case->key.len;
10148         ut_params->auth_xform.auth.key.data = key;
10149
10150         ut_params->sess = rte_cryptodev_sym_session_create(
10151                         ts_params->session_mpool);
10152
10153         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10154                         ut_params->sess, &ut_params->auth_xform,
10155                         ts_params->session_priv_mpool);
10156
10157         if (ut_params->sess == NULL)
10158                 return TEST_FAILED;
10159
10160         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10161
10162         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10163                         rte_pktmbuf_tailroom(ut_params->ibuf));
10164
10165         return 0;
10166 }
10167
10168 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10169                               const struct HMAC_MD5_vector *test_case,
10170                               uint8_t **plaintext)
10171 {
10172         uint16_t plaintext_pad_len;
10173
10174         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10175
10176         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10177                                 16);
10178
10179         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10180                         plaintext_pad_len);
10181         memcpy(*plaintext, test_case->plaintext.data,
10182                         test_case->plaintext.len);
10183
10184         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10185                         ut_params->ibuf, MD5_DIGEST_LEN);
10186         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10187                         "no room to append digest");
10188         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10189                         ut_params->ibuf, plaintext_pad_len);
10190
10191         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10192                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10193                            test_case->auth_tag.len);
10194         }
10195
10196         sym_op->auth.data.offset = 0;
10197         sym_op->auth.data.length = test_case->plaintext.len;
10198
10199         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10200         ut_params->op->sym->m_src = ut_params->ibuf;
10201
10202         return 0;
10203 }
10204
10205 static int
10206 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10207 {
10208         uint16_t plaintext_pad_len;
10209         uint8_t *plaintext, *auth_tag;
10210
10211         struct crypto_testsuite_params *ts_params = &testsuite_params;
10212         struct crypto_unittest_params *ut_params = &unittest_params;
10213         struct rte_cryptodev_info dev_info;
10214
10215         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10216         uint64_t feat_flags = dev_info.feature_flags;
10217
10218         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10219                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10220                 printf("Device doesn't support RAW data-path APIs.\n");
10221                 return -ENOTSUP;
10222         }
10223
10224         /* Verify the capabilities */
10225         struct rte_cryptodev_sym_capability_idx cap_idx;
10226         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10227         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10228         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10229                         &cap_idx) == NULL)
10230                 return -ENOTSUP;
10231
10232         if (MD5_HMAC_create_session(ts_params, ut_params,
10233                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10234                 return TEST_FAILED;
10235
10236         /* Generate Crypto op data structure */
10237         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10238                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10239         TEST_ASSERT_NOT_NULL(ut_params->op,
10240                         "Failed to allocate symmetric crypto operation struct");
10241
10242         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10243                                 16);
10244
10245         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10246                 return TEST_FAILED;
10247
10248         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10249                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10250                         ut_params->op);
10251         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10252                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10253                                 ut_params->op, 0, 1, 0, 0);
10254         else
10255                 TEST_ASSERT_NOT_NULL(
10256                         process_crypto_request(ts_params->valid_devs[0],
10257                                 ut_params->op),
10258                                 "failed to process sym crypto op");
10259
10260         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10261                         "crypto op processing failed");
10262
10263         if (ut_params->op->sym->m_dst) {
10264                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10265                                 uint8_t *, plaintext_pad_len);
10266         } else {
10267                 auth_tag = plaintext + plaintext_pad_len;
10268         }
10269
10270         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10271                         auth_tag,
10272                         test_case->auth_tag.data,
10273                         test_case->auth_tag.len,
10274                         "HMAC_MD5 generated tag not as expected");
10275
10276         return TEST_SUCCESS;
10277 }
10278
10279 static int
10280 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10281 {
10282         uint8_t *plaintext;
10283
10284         struct crypto_testsuite_params *ts_params = &testsuite_params;
10285         struct crypto_unittest_params *ut_params = &unittest_params;
10286         struct rte_cryptodev_info dev_info;
10287
10288         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10289         uint64_t feat_flags = dev_info.feature_flags;
10290
10291         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10292                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10293                 printf("Device doesn't support RAW data-path APIs.\n");
10294                 return -ENOTSUP;
10295         }
10296
10297         /* Verify the capabilities */
10298         struct rte_cryptodev_sym_capability_idx cap_idx;
10299         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10300         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10301         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10302                         &cap_idx) == NULL)
10303                 return -ENOTSUP;
10304
10305         if (MD5_HMAC_create_session(ts_params, ut_params,
10306                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
10307                 return TEST_FAILED;
10308         }
10309
10310         /* Generate Crypto op data structure */
10311         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10312                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10313         TEST_ASSERT_NOT_NULL(ut_params->op,
10314                         "Failed to allocate symmetric crypto operation struct");
10315
10316         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10317                 return TEST_FAILED;
10318
10319         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10320                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10321                         ut_params->op);
10322         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10323                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10324                                 ut_params->op, 0, 1, 0, 0);
10325         else
10326                 TEST_ASSERT_NOT_NULL(
10327                         process_crypto_request(ts_params->valid_devs[0],
10328                                 ut_params->op),
10329                                 "failed to process sym crypto op");
10330
10331         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10332                         "HMAC_MD5 crypto op processing failed");
10333
10334         return TEST_SUCCESS;
10335 }
10336
10337 static int
10338 test_MD5_HMAC_generate_case_1(void)
10339 {
10340         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
10341 }
10342
10343 static int
10344 test_MD5_HMAC_verify_case_1(void)
10345 {
10346         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
10347 }
10348
10349 static int
10350 test_MD5_HMAC_generate_case_2(void)
10351 {
10352         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
10353 }
10354
10355 static int
10356 test_MD5_HMAC_verify_case_2(void)
10357 {
10358         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
10359 }
10360
10361 static int
10362 test_multi_session(void)
10363 {
10364         struct crypto_testsuite_params *ts_params = &testsuite_params;
10365         struct crypto_unittest_params *ut_params = &unittest_params;
10366
10367         struct rte_cryptodev_info dev_info;
10368         struct rte_cryptodev_sym_session **sessions;
10369
10370         uint16_t i;
10371
10372         /* Verify the capabilities */
10373         struct rte_cryptodev_sym_capability_idx cap_idx;
10374         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10375         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10376         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10377                         &cap_idx) == NULL)
10378                 return -ENOTSUP;
10379         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10380         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10381         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10382                         &cap_idx) == NULL)
10383                 return -ENOTSUP;
10384
10385         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
10386                         aes_cbc_key, hmac_sha512_key);
10387
10388
10389         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10390
10391         sessions = rte_malloc(NULL,
10392                         (sizeof(struct rte_cryptodev_sym_session *) *
10393                         MAX_NB_SESSIONS) + 1, 0);
10394
10395         /* Create multiple crypto sessions*/
10396         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10397
10398                 sessions[i] = rte_cryptodev_sym_session_create(
10399                                 ts_params->session_mpool);
10400
10401                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10402                                 sessions[i], &ut_params->auth_xform,
10403                                 ts_params->session_priv_mpool);
10404                 TEST_ASSERT_NOT_NULL(sessions[i],
10405                                 "Session creation failed at session number %u",
10406                                 i);
10407
10408                 /* Attempt to send a request on each session */
10409                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
10410                         sessions[i],
10411                         ut_params,
10412                         ts_params,
10413                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
10414                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
10415                         aes_cbc_iv),
10416                         "Failed to perform decrypt on request number %u.", i);
10417                 /* free crypto operation structure */
10418                 if (ut_params->op)
10419                         rte_crypto_op_free(ut_params->op);
10420
10421                 /*
10422                  * free mbuf - both obuf and ibuf are usually the same,
10423                  * so check if they point at the same address is necessary,
10424                  * to avoid freeing the mbuf twice.
10425                  */
10426                 if (ut_params->obuf) {
10427                         rte_pktmbuf_free(ut_params->obuf);
10428                         if (ut_params->ibuf == ut_params->obuf)
10429                                 ut_params->ibuf = 0;
10430                         ut_params->obuf = 0;
10431                 }
10432                 if (ut_params->ibuf) {
10433                         rte_pktmbuf_free(ut_params->ibuf);
10434                         ut_params->ibuf = 0;
10435                 }
10436         }
10437
10438         /* Next session create should fail */
10439         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10440                         sessions[i], &ut_params->auth_xform,
10441                         ts_params->session_priv_mpool);
10442         TEST_ASSERT_NULL(sessions[i],
10443                         "Session creation succeeded unexpectedly!");
10444
10445         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10446                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10447                                 sessions[i]);
10448                 rte_cryptodev_sym_session_free(sessions[i]);
10449         }
10450
10451         rte_free(sessions);
10452
10453         return TEST_SUCCESS;
10454 }
10455
10456 struct multi_session_params {
10457         struct crypto_unittest_params ut_params;
10458         uint8_t *cipher_key;
10459         uint8_t *hmac_key;
10460         const uint8_t *cipher;
10461         const uint8_t *digest;
10462         uint8_t *iv;
10463 };
10464
10465 #define MB_SESSION_NUMBER 3
10466
10467 static int
10468 test_multi_session_random_usage(void)
10469 {
10470         struct crypto_testsuite_params *ts_params = &testsuite_params;
10471         struct rte_cryptodev_info dev_info;
10472         struct rte_cryptodev_sym_session **sessions;
10473         uint32_t i, j;
10474         struct multi_session_params ut_paramz[] = {
10475
10476                 {
10477                         .cipher_key = ms_aes_cbc_key0,
10478                         .hmac_key = ms_hmac_key0,
10479                         .cipher = ms_aes_cbc_cipher0,
10480                         .digest = ms_hmac_digest0,
10481                         .iv = ms_aes_cbc_iv0
10482                 },
10483                 {
10484                         .cipher_key = ms_aes_cbc_key1,
10485                         .hmac_key = ms_hmac_key1,
10486                         .cipher = ms_aes_cbc_cipher1,
10487                         .digest = ms_hmac_digest1,
10488                         .iv = ms_aes_cbc_iv1
10489                 },
10490                 {
10491                         .cipher_key = ms_aes_cbc_key2,
10492                         .hmac_key = ms_hmac_key2,
10493                         .cipher = ms_aes_cbc_cipher2,
10494                         .digest = ms_hmac_digest2,
10495                         .iv = ms_aes_cbc_iv2
10496                 },
10497
10498         };
10499
10500         /* Verify the capabilities */
10501         struct rte_cryptodev_sym_capability_idx cap_idx;
10502         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10503         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10504         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10505                         &cap_idx) == NULL)
10506                 return -ENOTSUP;
10507         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10508         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10509         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10510                         &cap_idx) == NULL)
10511                 return -ENOTSUP;
10512
10513         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10514
10515         sessions = rte_malloc(NULL,
10516                         (sizeof(struct rte_cryptodev_sym_session *)
10517                                         * MAX_NB_SESSIONS) + 1, 0);
10518
10519         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10520                 sessions[i] = rte_cryptodev_sym_session_create(
10521                                 ts_params->session_mpool);
10522
10523                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
10524                                 sizeof(struct crypto_unittest_params));
10525
10526                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
10527                                 &ut_paramz[i].ut_params,
10528                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
10529
10530                 /* Create multiple crypto sessions*/
10531                 rte_cryptodev_sym_session_init(
10532                                 ts_params->valid_devs[0],
10533                                 sessions[i],
10534                                 &ut_paramz[i].ut_params.auth_xform,
10535                                 ts_params->session_priv_mpool);
10536
10537                 TEST_ASSERT_NOT_NULL(sessions[i],
10538                                 "Session creation failed at session number %u",
10539                                 i);
10540
10541         }
10542
10543         srand(time(NULL));
10544         for (i = 0; i < 40000; i++) {
10545
10546                 j = rand() % MB_SESSION_NUMBER;
10547
10548                 TEST_ASSERT_SUCCESS(
10549                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
10550                                         sessions[j],
10551                                         &ut_paramz[j].ut_params,
10552                                         ts_params, ut_paramz[j].cipher,
10553                                         ut_paramz[j].digest,
10554                                         ut_paramz[j].iv),
10555                         "Failed to perform decrypt on request number %u.", i);
10556
10557                 if (ut_paramz[j].ut_params.op)
10558                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
10559
10560                 /*
10561                  * free mbuf - both obuf and ibuf are usually the same,
10562                  * so check if they point at the same address is necessary,
10563                  * to avoid freeing the mbuf twice.
10564                  */
10565                 if (ut_paramz[j].ut_params.obuf) {
10566                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
10567                         if (ut_paramz[j].ut_params.ibuf
10568                                         == ut_paramz[j].ut_params.obuf)
10569                                 ut_paramz[j].ut_params.ibuf = 0;
10570                         ut_paramz[j].ut_params.obuf = 0;
10571                 }
10572                 if (ut_paramz[j].ut_params.ibuf) {
10573                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
10574                         ut_paramz[j].ut_params.ibuf = 0;
10575                 }
10576         }
10577
10578         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10579                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10580                                 sessions[i]);
10581                 rte_cryptodev_sym_session_free(sessions[i]);
10582         }
10583
10584         rte_free(sessions);
10585
10586         return TEST_SUCCESS;
10587 }
10588
10589 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
10590                         0xab, 0xab, 0xab, 0xab,
10591                         0xab, 0xab, 0xab, 0xab,
10592                         0xab, 0xab, 0xab, 0xab};
10593
10594 static int
10595 test_null_invalid_operation(void)
10596 {
10597         struct crypto_testsuite_params *ts_params = &testsuite_params;
10598         struct crypto_unittest_params *ut_params = &unittest_params;
10599         int ret;
10600
10601         /* This test is for NULL PMD only */
10602         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10603                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10604                 return -ENOTSUP;
10605
10606         /* Setup Cipher Parameters */
10607         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10608         ut_params->cipher_xform.next = NULL;
10609
10610         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10611         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10612
10613         ut_params->sess = rte_cryptodev_sym_session_create(
10614                         ts_params->session_mpool);
10615
10616         /* Create Crypto session*/
10617         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10618                         ut_params->sess, &ut_params->cipher_xform,
10619                         ts_params->session_priv_mpool);
10620         TEST_ASSERT(ret < 0,
10621                         "Session creation succeeded unexpectedly");
10622
10623
10624         /* Setup HMAC Parameters */
10625         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10626         ut_params->auth_xform.next = NULL;
10627
10628         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10629         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10630
10631         ut_params->sess = rte_cryptodev_sym_session_create(
10632                         ts_params->session_mpool);
10633
10634         /* Create Crypto session*/
10635         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10636                         ut_params->sess, &ut_params->auth_xform,
10637                         ts_params->session_priv_mpool);
10638         TEST_ASSERT(ret < 0,
10639                         "Session creation succeeded unexpectedly");
10640
10641         return TEST_SUCCESS;
10642 }
10643
10644
10645 #define NULL_BURST_LENGTH (32)
10646
10647 static int
10648 test_null_burst_operation(void)
10649 {
10650         struct crypto_testsuite_params *ts_params = &testsuite_params;
10651         struct crypto_unittest_params *ut_params = &unittest_params;
10652
10653         unsigned i, burst_len = NULL_BURST_LENGTH;
10654
10655         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10656         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10657
10658         /* This test is for NULL PMD only */
10659         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10660                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10661                 return -ENOTSUP;
10662
10663         /* Setup Cipher Parameters */
10664         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10665         ut_params->cipher_xform.next = &ut_params->auth_xform;
10666
10667         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10668         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10669
10670         /* Setup HMAC Parameters */
10671         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10672         ut_params->auth_xform.next = NULL;
10673
10674         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10675         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10676
10677         ut_params->sess = rte_cryptodev_sym_session_create(
10678                         ts_params->session_mpool);
10679
10680         /* Create Crypto session*/
10681         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10682                         ut_params->sess, &ut_params->cipher_xform,
10683                         ts_params->session_priv_mpool);
10684         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10685
10686         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10687                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10688                         burst_len, "failed to generate burst of crypto ops");
10689
10690         /* Generate an operation for each mbuf in burst */
10691         for (i = 0; i < burst_len; i++) {
10692                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10693
10694                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10695
10696                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10697                                 sizeof(unsigned));
10698                 *data = i;
10699
10700                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10701
10702                 burst[i]->sym->m_src = m;
10703         }
10704
10705         /* Process crypto operation */
10706         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10707                         0, burst, burst_len),
10708                         burst_len,
10709                         "Error enqueuing burst");
10710
10711         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10712                         0, burst_dequeued, burst_len),
10713                         burst_len,
10714                         "Error dequeuing burst");
10715
10716
10717         for (i = 0; i < burst_len; i++) {
10718                 TEST_ASSERT_EQUAL(
10719                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10720                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10721                                         uint32_t *),
10722                         "data not as expected");
10723
10724                 rte_pktmbuf_free(burst[i]->sym->m_src);
10725                 rte_crypto_op_free(burst[i]);
10726         }
10727
10728         return TEST_SUCCESS;
10729 }
10730
10731 static void
10732 generate_gmac_large_plaintext(uint8_t *data)
10733 {
10734         uint16_t i;
10735
10736         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10737                 memcpy(&data[i], &data[0], 32);
10738 }
10739
10740 static int
10741 create_gmac_operation(enum rte_crypto_auth_operation op,
10742                 const struct gmac_test_data *tdata)
10743 {
10744         struct crypto_testsuite_params *ts_params = &testsuite_params;
10745         struct crypto_unittest_params *ut_params = &unittest_params;
10746         struct rte_crypto_sym_op *sym_op;
10747
10748         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10749
10750         /* Generate Crypto op data structure */
10751         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10752                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10753         TEST_ASSERT_NOT_NULL(ut_params->op,
10754                         "Failed to allocate symmetric crypto operation struct");
10755
10756         sym_op = ut_params->op->sym;
10757
10758         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10759                         ut_params->ibuf, tdata->gmac_tag.len);
10760         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10761                         "no room to append digest");
10762
10763         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10764                         ut_params->ibuf, plaintext_pad_len);
10765
10766         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10767                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10768                                 tdata->gmac_tag.len);
10769                 debug_hexdump(stdout, "digest:",
10770                                 sym_op->auth.digest.data,
10771                                 tdata->gmac_tag.len);
10772         }
10773
10774         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10775                         uint8_t *, IV_OFFSET);
10776
10777         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10778
10779         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10780
10781         sym_op->cipher.data.length = 0;
10782         sym_op->cipher.data.offset = 0;
10783
10784         sym_op->auth.data.offset = 0;
10785         sym_op->auth.data.length = tdata->plaintext.len;
10786
10787         return 0;
10788 }
10789
10790 static int
10791 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
10792                 const struct gmac_test_data *tdata,
10793                 void *digest_mem, uint64_t digest_phys)
10794 {
10795         struct crypto_testsuite_params *ts_params = &testsuite_params;
10796         struct crypto_unittest_params *ut_params = &unittest_params;
10797         struct rte_crypto_sym_op *sym_op;
10798
10799         /* Generate Crypto op data structure */
10800         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10801                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10802         TEST_ASSERT_NOT_NULL(ut_params->op,
10803                         "Failed to allocate symmetric crypto operation struct");
10804
10805         sym_op = ut_params->op->sym;
10806
10807         sym_op->auth.digest.data = digest_mem;
10808         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10809                         "no room to append digest");
10810
10811         sym_op->auth.digest.phys_addr = digest_phys;
10812
10813         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10814                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10815                                 tdata->gmac_tag.len);
10816                 debug_hexdump(stdout, "digest:",
10817                                 sym_op->auth.digest.data,
10818                                 tdata->gmac_tag.len);
10819         }
10820
10821         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10822                         uint8_t *, IV_OFFSET);
10823
10824         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10825
10826         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10827
10828         sym_op->cipher.data.length = 0;
10829         sym_op->cipher.data.offset = 0;
10830
10831         sym_op->auth.data.offset = 0;
10832         sym_op->auth.data.length = tdata->plaintext.len;
10833
10834         return 0;
10835 }
10836
10837 static int create_gmac_session(uint8_t dev_id,
10838                 const struct gmac_test_data *tdata,
10839                 enum rte_crypto_auth_operation auth_op)
10840 {
10841         uint8_t auth_key[tdata->key.len];
10842
10843         struct crypto_testsuite_params *ts_params = &testsuite_params;
10844         struct crypto_unittest_params *ut_params = &unittest_params;
10845
10846         memcpy(auth_key, tdata->key.data, tdata->key.len);
10847
10848         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10849         ut_params->auth_xform.next = NULL;
10850
10851         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
10852         ut_params->auth_xform.auth.op = auth_op;
10853         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
10854         ut_params->auth_xform.auth.key.length = tdata->key.len;
10855         ut_params->auth_xform.auth.key.data = auth_key;
10856         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10857         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
10858
10859
10860         ut_params->sess = rte_cryptodev_sym_session_create(
10861                         ts_params->session_mpool);
10862
10863         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10864                         &ut_params->auth_xform,
10865                         ts_params->session_priv_mpool);
10866
10867         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10868
10869         return 0;
10870 }
10871
10872 static int
10873 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
10874 {
10875         struct crypto_testsuite_params *ts_params = &testsuite_params;
10876         struct crypto_unittest_params *ut_params = &unittest_params;
10877         struct rte_cryptodev_info dev_info;
10878
10879         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10880         uint64_t feat_flags = dev_info.feature_flags;
10881
10882         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10883                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10884                 printf("Device doesn't support RAW data-path APIs.\n");
10885                 return -ENOTSUP;
10886         }
10887
10888         int retval;
10889
10890         uint8_t *auth_tag, *plaintext;
10891         uint16_t plaintext_pad_len;
10892
10893         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10894                               "No GMAC length in the source data");
10895
10896         /* Verify the capabilities */
10897         struct rte_cryptodev_sym_capability_idx cap_idx;
10898         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10899         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10900         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10901                         &cap_idx) == NULL)
10902                 return -ENOTSUP;
10903
10904         retval = create_gmac_session(ts_params->valid_devs[0],
10905                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
10906
10907         if (retval < 0)
10908                 return retval;
10909
10910         if (tdata->plaintext.len > MBUF_SIZE)
10911                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10912         else
10913                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10914         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10915                         "Failed to allocate input buffer in mempool");
10916
10917         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10918                         rte_pktmbuf_tailroom(ut_params->ibuf));
10919
10920         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10921         /*
10922          * Runtime generate the large plain text instead of use hard code
10923          * plain text vector. It is done to avoid create huge source file
10924          * with the test vector.
10925          */
10926         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10927                 generate_gmac_large_plaintext(tdata->plaintext.data);
10928
10929         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10930                                 plaintext_pad_len);
10931         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10932
10933         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10934         debug_hexdump(stdout, "plaintext:", plaintext,
10935                         tdata->plaintext.len);
10936
10937         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
10938                         tdata);
10939
10940         if (retval < 0)
10941                 return retval;
10942
10943         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10944
10945         ut_params->op->sym->m_src = ut_params->ibuf;
10946
10947         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10948                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10949                         ut_params->op);
10950         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10951                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10952                                 ut_params->op, 0, 1, 0, 0);
10953         else
10954                 TEST_ASSERT_NOT_NULL(
10955                         process_crypto_request(ts_params->valid_devs[0],
10956                         ut_params->op), "failed to process sym crypto op");
10957
10958         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10959                         "crypto op processing failed");
10960
10961         if (ut_params->op->sym->m_dst) {
10962                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10963                                 uint8_t *, plaintext_pad_len);
10964         } else {
10965                 auth_tag = plaintext + plaintext_pad_len;
10966         }
10967
10968         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
10969
10970         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10971                         auth_tag,
10972                         tdata->gmac_tag.data,
10973                         tdata->gmac_tag.len,
10974                         "GMAC Generated auth tag not as expected");
10975
10976         return 0;
10977 }
10978
10979 static int
10980 test_AES_GMAC_authentication_test_case_1(void)
10981 {
10982         return test_AES_GMAC_authentication(&gmac_test_case_1);
10983 }
10984
10985 static int
10986 test_AES_GMAC_authentication_test_case_2(void)
10987 {
10988         return test_AES_GMAC_authentication(&gmac_test_case_2);
10989 }
10990
10991 static int
10992 test_AES_GMAC_authentication_test_case_3(void)
10993 {
10994         return test_AES_GMAC_authentication(&gmac_test_case_3);
10995 }
10996
10997 static int
10998 test_AES_GMAC_authentication_test_case_4(void)
10999 {
11000         return test_AES_GMAC_authentication(&gmac_test_case_4);
11001 }
11002
11003 static int
11004 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11005 {
11006         struct crypto_testsuite_params *ts_params = &testsuite_params;
11007         struct crypto_unittest_params *ut_params = &unittest_params;
11008         int retval;
11009         uint32_t plaintext_pad_len;
11010         uint8_t *plaintext;
11011         struct rte_cryptodev_info dev_info;
11012
11013         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11014         uint64_t feat_flags = dev_info.feature_flags;
11015
11016         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11017                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11018                 printf("Device doesn't support RAW data-path APIs.\n");
11019                 return -ENOTSUP;
11020         }
11021
11022         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11023                               "No GMAC length in the source data");
11024
11025         /* Verify the capabilities */
11026         struct rte_cryptodev_sym_capability_idx cap_idx;
11027         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11028         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11029         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11030                         &cap_idx) == NULL)
11031                 return -ENOTSUP;
11032
11033         retval = create_gmac_session(ts_params->valid_devs[0],
11034                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11035
11036         if (retval < 0)
11037                 return retval;
11038
11039         if (tdata->plaintext.len > MBUF_SIZE)
11040                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11041         else
11042                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11043         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11044                         "Failed to allocate input buffer in mempool");
11045
11046         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11047                         rte_pktmbuf_tailroom(ut_params->ibuf));
11048
11049         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11050
11051         /*
11052          * Runtime generate the large plain text instead of use hard code
11053          * plain text vector. It is done to avoid create huge source file
11054          * with the test vector.
11055          */
11056         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11057                 generate_gmac_large_plaintext(tdata->plaintext.data);
11058
11059         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11060                                 plaintext_pad_len);
11061         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11062
11063         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11064         debug_hexdump(stdout, "plaintext:", plaintext,
11065                         tdata->plaintext.len);
11066
11067         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
11068                         tdata);
11069
11070         if (retval < 0)
11071                 return retval;
11072
11073         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11074
11075         ut_params->op->sym->m_src = ut_params->ibuf;
11076
11077         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11078                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11079                         ut_params->op);
11080         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11081                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11082                                 ut_params->op, 0, 1, 0, 0);
11083         else
11084                 TEST_ASSERT_NOT_NULL(
11085                         process_crypto_request(ts_params->valid_devs[0],
11086                         ut_params->op), "failed to process sym crypto op");
11087
11088         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11089                         "crypto op processing failed");
11090
11091         return 0;
11092
11093 }
11094
11095 static int
11096 test_AES_GMAC_authentication_verify_test_case_1(void)
11097 {
11098         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
11099 }
11100
11101 static int
11102 test_AES_GMAC_authentication_verify_test_case_2(void)
11103 {
11104         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
11105 }
11106
11107 static int
11108 test_AES_GMAC_authentication_verify_test_case_3(void)
11109 {
11110         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
11111 }
11112
11113 static int
11114 test_AES_GMAC_authentication_verify_test_case_4(void)
11115 {
11116         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
11117 }
11118
11119 static int
11120 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
11121                                 uint32_t fragsz)
11122 {
11123         struct crypto_testsuite_params *ts_params = &testsuite_params;
11124         struct crypto_unittest_params *ut_params = &unittest_params;
11125         struct rte_cryptodev_info dev_info;
11126         uint64_t feature_flags;
11127         unsigned int trn_data = 0;
11128         void *digest_mem = NULL;
11129         uint32_t segs = 1;
11130         unsigned int to_trn = 0;
11131         struct rte_mbuf *buf = NULL;
11132         uint8_t *auth_tag, *plaintext;
11133         int retval;
11134
11135         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11136                               "No GMAC length in the source data");
11137
11138         /* Verify the capabilities */
11139         struct rte_cryptodev_sym_capability_idx cap_idx;
11140         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11141         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11142         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11143                         &cap_idx) == NULL)
11144                 return -ENOTSUP;
11145
11146         /* Check for any input SGL support */
11147         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11148         feature_flags = dev_info.feature_flags;
11149
11150         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) &&
11151                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) &&
11152                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
11153                 return -ENOTSUP;
11154
11155         if (fragsz > tdata->plaintext.len)
11156                 fragsz = tdata->plaintext.len;
11157
11158         uint16_t plaintext_len = fragsz;
11159
11160         retval = create_gmac_session(ts_params->valid_devs[0],
11161                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11162
11163         if (retval < 0)
11164                 return retval;
11165
11166         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11167         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11168                         "Failed to allocate input buffer in mempool");
11169
11170         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11171                         rte_pktmbuf_tailroom(ut_params->ibuf));
11172
11173         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11174                                 plaintext_len);
11175         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11176
11177         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11178
11179         trn_data += plaintext_len;
11180
11181         buf = ut_params->ibuf;
11182
11183         /*
11184          * Loop until no more fragments
11185          */
11186
11187         while (trn_data < tdata->plaintext.len) {
11188                 ++segs;
11189                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11190                                 (tdata->plaintext.len - trn_data) : fragsz;
11191
11192                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11193                 buf = buf->next;
11194
11195                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11196                                 rte_pktmbuf_tailroom(buf));
11197
11198                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11199                                 to_trn);
11200
11201                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11202                                 to_trn);
11203                 trn_data += to_trn;
11204                 if (trn_data  == tdata->plaintext.len)
11205                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11206                                         tdata->gmac_tag.len);
11207         }
11208         ut_params->ibuf->nb_segs = segs;
11209
11210         /*
11211          * Place digest at the end of the last buffer
11212          */
11213         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11214
11215         if (!digest_mem) {
11216                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11217                                 + tdata->gmac_tag.len);
11218                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11219                                 tdata->plaintext.len);
11220         }
11221
11222         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
11223                         tdata, digest_mem, digest_phys);
11224
11225         if (retval < 0)
11226                 return retval;
11227
11228         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11229
11230         ut_params->op->sym->m_src = ut_params->ibuf;
11231
11232         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11233                 return -ENOTSUP;
11234
11235         TEST_ASSERT_NOT_NULL(
11236                 process_crypto_request(ts_params->valid_devs[0],
11237                 ut_params->op), "failed to process sym crypto op");
11238
11239         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11240                         "crypto op processing failed");
11241
11242         auth_tag = digest_mem;
11243         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11244         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11245                         auth_tag,
11246                         tdata->gmac_tag.data,
11247                         tdata->gmac_tag.len,
11248                         "GMAC Generated auth tag not as expected");
11249
11250         return 0;
11251 }
11252
11253 /* Segment size not multiple of block size (16B) */
11254 static int
11255 test_AES_GMAC_authentication_SGL_40B(void)
11256 {
11257         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
11258 }
11259
11260 static int
11261 test_AES_GMAC_authentication_SGL_80B(void)
11262 {
11263         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
11264 }
11265
11266 static int
11267 test_AES_GMAC_authentication_SGL_2048B(void)
11268 {
11269         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
11270 }
11271
11272 /* Segment size not multiple of block size (16B) */
11273 static int
11274 test_AES_GMAC_authentication_SGL_2047B(void)
11275 {
11276         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
11277 }
11278
11279 struct test_crypto_vector {
11280         enum rte_crypto_cipher_algorithm crypto_algo;
11281         unsigned int cipher_offset;
11282         unsigned int cipher_len;
11283
11284         struct {
11285                 uint8_t data[64];
11286                 unsigned int len;
11287         } cipher_key;
11288
11289         struct {
11290                 uint8_t data[64];
11291                 unsigned int len;
11292         } iv;
11293
11294         struct {
11295                 const uint8_t *data;
11296                 unsigned int len;
11297         } plaintext;
11298
11299         struct {
11300                 const uint8_t *data;
11301                 unsigned int len;
11302         } ciphertext;
11303
11304         enum rte_crypto_auth_algorithm auth_algo;
11305         unsigned int auth_offset;
11306
11307         struct {
11308                 uint8_t data[128];
11309                 unsigned int len;
11310         } auth_key;
11311
11312         struct {
11313                 const uint8_t *data;
11314                 unsigned int len;
11315         } aad;
11316
11317         struct {
11318                 uint8_t data[128];
11319                 unsigned int len;
11320         } digest;
11321 };
11322
11323 static const struct test_crypto_vector
11324 hmac_sha1_test_crypto_vector = {
11325         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11326         .plaintext = {
11327                 .data = plaintext_hash,
11328                 .len = 512
11329         },
11330         .auth_key = {
11331                 .data = {
11332                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11333                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11334                         0xDE, 0xF4, 0xDE, 0xAD
11335                 },
11336                 .len = 20
11337         },
11338         .digest = {
11339                 .data = {
11340                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
11341                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
11342                         0x3F, 0x91, 0x64, 0x59
11343                 },
11344                 .len = 20
11345         }
11346 };
11347
11348 static const struct test_crypto_vector
11349 aes128_gmac_test_vector = {
11350         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
11351         .plaintext = {
11352                 .data = plaintext_hash,
11353                 .len = 512
11354         },
11355         .iv = {
11356                 .data = {
11357                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11358                         0x08, 0x09, 0x0A, 0x0B
11359                 },
11360                 .len = 12
11361         },
11362         .auth_key = {
11363                 .data = {
11364                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11365                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
11366                 },
11367                 .len = 16
11368         },
11369         .digest = {
11370                 .data = {
11371                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
11372                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
11373                 },
11374                 .len = 16
11375         }
11376 };
11377
11378 static const struct test_crypto_vector
11379 aes128cbc_hmac_sha1_test_vector = {
11380         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11381         .cipher_offset = 0,
11382         .cipher_len = 512,
11383         .cipher_key = {
11384                 .data = {
11385                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11386                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11387                 },
11388                 .len = 16
11389         },
11390         .iv = {
11391                 .data = {
11392                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11393                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11394                 },
11395                 .len = 16
11396         },
11397         .plaintext = {
11398                 .data = plaintext_hash,
11399                 .len = 512
11400         },
11401         .ciphertext = {
11402                 .data = ciphertext512_aes128cbc,
11403                 .len = 512
11404         },
11405         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11406         .auth_offset = 0,
11407         .auth_key = {
11408                 .data = {
11409                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11410                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11411                         0xDE, 0xF4, 0xDE, 0xAD
11412                 },
11413                 .len = 20
11414         },
11415         .digest = {
11416                 .data = {
11417                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
11418                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11419                         0x18, 0x8C, 0x1D, 0x32
11420                 },
11421                 .len = 20
11422         }
11423 };
11424
11425 static const struct test_crypto_vector
11426 aes128cbc_hmac_sha1_aad_test_vector = {
11427         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11428         .cipher_offset = 8,
11429         .cipher_len = 496,
11430         .cipher_key = {
11431                 .data = {
11432                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11433                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11434                 },
11435                 .len = 16
11436         },
11437         .iv = {
11438                 .data = {
11439                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11440                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11441                 },
11442                 .len = 16
11443         },
11444         .plaintext = {
11445                 .data = plaintext_hash,
11446                 .len = 512
11447         },
11448         .ciphertext = {
11449                 .data = ciphertext512_aes128cbc_aad,
11450                 .len = 512
11451         },
11452         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11453         .auth_offset = 0,
11454         .auth_key = {
11455                 .data = {
11456                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11457                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11458                         0xDE, 0xF4, 0xDE, 0xAD
11459                 },
11460                 .len = 20
11461         },
11462         .digest = {
11463                 .data = {
11464                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
11465                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
11466                         0x62, 0x0F, 0xFB, 0x10
11467                 },
11468                 .len = 20
11469         }
11470 };
11471
11472 static void
11473 data_corruption(uint8_t *data)
11474 {
11475         data[0] += 1;
11476 }
11477
11478 static void
11479 tag_corruption(uint8_t *data, unsigned int tag_offset)
11480 {
11481         data[tag_offset] += 1;
11482 }
11483
11484 static int
11485 create_auth_session(struct crypto_unittest_params *ut_params,
11486                 uint8_t dev_id,
11487                 const struct test_crypto_vector *reference,
11488                 enum rte_crypto_auth_operation auth_op)
11489 {
11490         struct crypto_testsuite_params *ts_params = &testsuite_params;
11491         uint8_t auth_key[reference->auth_key.len + 1];
11492
11493         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11494
11495         /* Setup Authentication Parameters */
11496         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11497         ut_params->auth_xform.auth.op = auth_op;
11498         ut_params->auth_xform.next = NULL;
11499         ut_params->auth_xform.auth.algo = reference->auth_algo;
11500         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11501         ut_params->auth_xform.auth.key.data = auth_key;
11502         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11503
11504         /* Create Crypto session*/
11505         ut_params->sess = rte_cryptodev_sym_session_create(
11506                         ts_params->session_mpool);
11507
11508         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11509                                 &ut_params->auth_xform,
11510                                 ts_params->session_priv_mpool);
11511
11512         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11513
11514         return 0;
11515 }
11516
11517 static int
11518 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
11519                 uint8_t dev_id,
11520                 const struct test_crypto_vector *reference,
11521                 enum rte_crypto_auth_operation auth_op,
11522                 enum rte_crypto_cipher_operation cipher_op)
11523 {
11524         struct crypto_testsuite_params *ts_params = &testsuite_params;
11525         uint8_t cipher_key[reference->cipher_key.len + 1];
11526         uint8_t auth_key[reference->auth_key.len + 1];
11527
11528         memcpy(cipher_key, reference->cipher_key.data,
11529                         reference->cipher_key.len);
11530         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11531
11532         /* Setup Authentication Parameters */
11533         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11534         ut_params->auth_xform.auth.op = auth_op;
11535         ut_params->auth_xform.auth.algo = reference->auth_algo;
11536         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11537         ut_params->auth_xform.auth.key.data = auth_key;
11538         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11539
11540         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
11541                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11542                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
11543         } else {
11544                 ut_params->auth_xform.next = &ut_params->cipher_xform;
11545
11546                 /* Setup Cipher Parameters */
11547                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11548                 ut_params->cipher_xform.next = NULL;
11549                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11550                 ut_params->cipher_xform.cipher.op = cipher_op;
11551                 ut_params->cipher_xform.cipher.key.data = cipher_key;
11552                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11553                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11554                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11555         }
11556
11557         /* Create Crypto session*/
11558         ut_params->sess = rte_cryptodev_sym_session_create(
11559                         ts_params->session_mpool);
11560
11561         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11562                                 &ut_params->auth_xform,
11563                                 ts_params->session_priv_mpool);
11564
11565         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11566
11567         return 0;
11568 }
11569
11570 static int
11571 create_auth_operation(struct crypto_testsuite_params *ts_params,
11572                 struct crypto_unittest_params *ut_params,
11573                 const struct test_crypto_vector *reference,
11574                 unsigned int auth_generate)
11575 {
11576         /* Generate Crypto op data structure */
11577         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11578                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11579         TEST_ASSERT_NOT_NULL(ut_params->op,
11580                         "Failed to allocate pktmbuf offload");
11581
11582         /* Set crypto operation data parameters */
11583         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11584
11585         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11586
11587         /* set crypto operation source mbuf */
11588         sym_op->m_src = ut_params->ibuf;
11589
11590         /* digest */
11591         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11592                         ut_params->ibuf, reference->digest.len);
11593
11594         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11595                         "no room to append auth tag");
11596
11597         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11598                         ut_params->ibuf, reference->plaintext.len);
11599
11600         if (auth_generate)
11601                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11602         else
11603                 memcpy(sym_op->auth.digest.data,
11604                                 reference->digest.data,
11605                                 reference->digest.len);
11606
11607         debug_hexdump(stdout, "digest:",
11608                         sym_op->auth.digest.data,
11609                         reference->digest.len);
11610
11611         sym_op->auth.data.length = reference->plaintext.len;
11612         sym_op->auth.data.offset = 0;
11613
11614         return 0;
11615 }
11616
11617 static int
11618 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
11619                 struct crypto_unittest_params *ut_params,
11620                 const struct test_crypto_vector *reference,
11621                 unsigned int auth_generate)
11622 {
11623         /* Generate Crypto op data structure */
11624         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11625                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11626         TEST_ASSERT_NOT_NULL(ut_params->op,
11627                         "Failed to allocate pktmbuf offload");
11628
11629         /* Set crypto operation data parameters */
11630         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11631
11632         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11633
11634         /* set crypto operation source mbuf */
11635         sym_op->m_src = ut_params->ibuf;
11636
11637         /* digest */
11638         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11639                         ut_params->ibuf, reference->digest.len);
11640
11641         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11642                         "no room to append auth tag");
11643
11644         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11645                         ut_params->ibuf, reference->ciphertext.len);
11646
11647         if (auth_generate)
11648                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11649         else
11650                 memcpy(sym_op->auth.digest.data,
11651                                 reference->digest.data,
11652                                 reference->digest.len);
11653
11654         debug_hexdump(stdout, "digest:",
11655                         sym_op->auth.digest.data,
11656                         reference->digest.len);
11657
11658         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11659                         reference->iv.data, reference->iv.len);
11660
11661         sym_op->cipher.data.length = 0;
11662         sym_op->cipher.data.offset = 0;
11663
11664         sym_op->auth.data.length = reference->plaintext.len;
11665         sym_op->auth.data.offset = 0;
11666
11667         return 0;
11668 }
11669
11670 static int
11671 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
11672                 struct crypto_unittest_params *ut_params,
11673                 const struct test_crypto_vector *reference,
11674                 unsigned int auth_generate)
11675 {
11676         /* Generate Crypto op data structure */
11677         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11678                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11679         TEST_ASSERT_NOT_NULL(ut_params->op,
11680                         "Failed to allocate pktmbuf offload");
11681
11682         /* Set crypto operation data parameters */
11683         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11684
11685         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11686
11687         /* set crypto operation source mbuf */
11688         sym_op->m_src = ut_params->ibuf;
11689
11690         /* digest */
11691         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11692                         ut_params->ibuf, reference->digest.len);
11693
11694         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11695                         "no room to append auth tag");
11696
11697         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11698                         ut_params->ibuf, reference->ciphertext.len);
11699
11700         if (auth_generate)
11701                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11702         else
11703                 memcpy(sym_op->auth.digest.data,
11704                                 reference->digest.data,
11705                                 reference->digest.len);
11706
11707         debug_hexdump(stdout, "digest:",
11708                         sym_op->auth.digest.data,
11709                         reference->digest.len);
11710
11711         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11712                         reference->iv.data, reference->iv.len);
11713
11714         sym_op->cipher.data.length = reference->cipher_len;
11715         sym_op->cipher.data.offset = reference->cipher_offset;
11716
11717         sym_op->auth.data.length = reference->plaintext.len;
11718         sym_op->auth.data.offset = reference->auth_offset;
11719
11720         return 0;
11721 }
11722
11723 static int
11724 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11725                 struct crypto_unittest_params *ut_params,
11726                 const struct test_crypto_vector *reference)
11727 {
11728         return create_auth_operation(ts_params, ut_params, reference, 0);
11729 }
11730
11731 static int
11732 create_auth_verify_GMAC_operation(
11733                 struct crypto_testsuite_params *ts_params,
11734                 struct crypto_unittest_params *ut_params,
11735                 const struct test_crypto_vector *reference)
11736 {
11737         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11738 }
11739
11740 static int
11741 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11742                 struct crypto_unittest_params *ut_params,
11743                 const struct test_crypto_vector *reference)
11744 {
11745         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11746 }
11747
11748 static int
11749 test_authentication_verify_fail_when_data_corruption(
11750                 struct crypto_testsuite_params *ts_params,
11751                 struct crypto_unittest_params *ut_params,
11752                 const struct test_crypto_vector *reference,
11753                 unsigned int data_corrupted)
11754 {
11755         int retval;
11756
11757         uint8_t *plaintext;
11758         struct rte_cryptodev_info dev_info;
11759
11760         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11761         uint64_t feat_flags = dev_info.feature_flags;
11762
11763         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11764                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11765                 printf("Device doesn't support RAW data-path APIs.\n");
11766                 return -ENOTSUP;
11767         }
11768
11769         /* Verify the capabilities */
11770         struct rte_cryptodev_sym_capability_idx cap_idx;
11771         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11772         cap_idx.algo.auth = reference->auth_algo;
11773         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11774                         &cap_idx) == NULL)
11775                 return -ENOTSUP;
11776
11777
11778         /* Create session */
11779         retval = create_auth_session(ut_params,
11780                         ts_params->valid_devs[0],
11781                         reference,
11782                         RTE_CRYPTO_AUTH_OP_VERIFY);
11783         if (retval < 0)
11784                 return retval;
11785
11786         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11787         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11788                         "Failed to allocate input buffer in mempool");
11789
11790         /* clear mbuf payload */
11791         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11792                         rte_pktmbuf_tailroom(ut_params->ibuf));
11793
11794         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11795                         reference->plaintext.len);
11796         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11797         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11798
11799         debug_hexdump(stdout, "plaintext:", plaintext,
11800                 reference->plaintext.len);
11801
11802         /* Create operation */
11803         retval = create_auth_verify_operation(ts_params, ut_params, reference);
11804
11805         if (retval < 0)
11806                 return retval;
11807
11808         if (data_corrupted)
11809                 data_corruption(plaintext);
11810         else
11811                 tag_corruption(plaintext, reference->plaintext.len);
11812
11813         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11814                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11815                         ut_params->op);
11816                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11817                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11818                         "authentication not failed");
11819         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11820                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11821                                 ut_params->op, 0, 1, 0, 0);
11822         else {
11823                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11824                         ut_params->op);
11825                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11826         }
11827
11828         return 0;
11829 }
11830
11831 static int
11832 test_authentication_verify_GMAC_fail_when_corruption(
11833                 struct crypto_testsuite_params *ts_params,
11834                 struct crypto_unittest_params *ut_params,
11835                 const struct test_crypto_vector *reference,
11836                 unsigned int data_corrupted)
11837 {
11838         int retval;
11839         uint8_t *plaintext;
11840         struct rte_cryptodev_info dev_info;
11841
11842         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11843         uint64_t feat_flags = dev_info.feature_flags;
11844
11845         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11846                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11847                 printf("Device doesn't support RAW data-path APIs.\n");
11848                 return -ENOTSUP;
11849         }
11850
11851         /* Verify the capabilities */
11852         struct rte_cryptodev_sym_capability_idx cap_idx;
11853         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11854         cap_idx.algo.auth = reference->auth_algo;
11855         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11856                         &cap_idx) == NULL)
11857                 return -ENOTSUP;
11858
11859         /* Create session */
11860         retval = create_auth_cipher_session(ut_params,
11861                         ts_params->valid_devs[0],
11862                         reference,
11863                         RTE_CRYPTO_AUTH_OP_VERIFY,
11864                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11865         if (retval < 0)
11866                 return retval;
11867
11868         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11869         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11870                         "Failed to allocate input buffer in mempool");
11871
11872         /* clear mbuf payload */
11873         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11874                         rte_pktmbuf_tailroom(ut_params->ibuf));
11875
11876         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11877                         reference->plaintext.len);
11878         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11879         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11880
11881         debug_hexdump(stdout, "plaintext:", plaintext,
11882                 reference->plaintext.len);
11883
11884         /* Create operation */
11885         retval = create_auth_verify_GMAC_operation(ts_params,
11886                         ut_params,
11887                         reference);
11888
11889         if (retval < 0)
11890                 return retval;
11891
11892         if (data_corrupted)
11893                 data_corruption(plaintext);
11894         else
11895                 tag_corruption(plaintext, reference->aad.len);
11896
11897         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11898                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11899                         ut_params->op);
11900                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11901                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11902                         "authentication not failed");
11903         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11904                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11905                                 ut_params->op, 0, 1, 0, 0);
11906         else {
11907                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11908                         ut_params->op);
11909                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11910         }
11911
11912         return 0;
11913 }
11914
11915 static int
11916 test_authenticated_decryption_fail_when_corruption(
11917                 struct crypto_testsuite_params *ts_params,
11918                 struct crypto_unittest_params *ut_params,
11919                 const struct test_crypto_vector *reference,
11920                 unsigned int data_corrupted)
11921 {
11922         int retval;
11923
11924         uint8_t *ciphertext;
11925         struct rte_cryptodev_info dev_info;
11926
11927         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11928         uint64_t feat_flags = dev_info.feature_flags;
11929
11930         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11931                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11932                 printf("Device doesn't support RAW data-path APIs.\n");
11933                 return -ENOTSUP;
11934         }
11935
11936         /* Verify the capabilities */
11937         struct rte_cryptodev_sym_capability_idx cap_idx;
11938         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11939         cap_idx.algo.auth = reference->auth_algo;
11940         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11941                         &cap_idx) == NULL)
11942                 return -ENOTSUP;
11943         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11944         cap_idx.algo.cipher = reference->crypto_algo;
11945         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11946                         &cap_idx) == NULL)
11947                 return -ENOTSUP;
11948
11949         /* Create session */
11950         retval = create_auth_cipher_session(ut_params,
11951                         ts_params->valid_devs[0],
11952                         reference,
11953                         RTE_CRYPTO_AUTH_OP_VERIFY,
11954                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11955         if (retval < 0)
11956                 return retval;
11957
11958         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11959         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11960                         "Failed to allocate input buffer in mempool");
11961
11962         /* clear mbuf payload */
11963         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11964                         rte_pktmbuf_tailroom(ut_params->ibuf));
11965
11966         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11967                         reference->ciphertext.len);
11968         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11969         memcpy(ciphertext, reference->ciphertext.data,
11970                         reference->ciphertext.len);
11971
11972         /* Create operation */
11973         retval = create_cipher_auth_verify_operation(ts_params,
11974                         ut_params,
11975                         reference);
11976
11977         if (retval < 0)
11978                 return retval;
11979
11980         if (data_corrupted)
11981                 data_corruption(ciphertext);
11982         else
11983                 tag_corruption(ciphertext, reference->ciphertext.len);
11984
11985         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11986                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11987                         ut_params->op);
11988                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11989                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11990                         "authentication not failed");
11991         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11992                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11993                                 ut_params->op, 1, 1, 0, 0);
11994         else {
11995                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11996                         ut_params->op);
11997                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11998         }
11999
12000         return 0;
12001 }
12002
12003 static int
12004 test_authenticated_encryt_with_esn(
12005                 struct crypto_testsuite_params *ts_params,
12006                 struct crypto_unittest_params *ut_params,
12007                 const struct test_crypto_vector *reference)
12008 {
12009         int retval;
12010
12011         uint8_t *authciphertext, *plaintext, *auth_tag;
12012         uint16_t plaintext_pad_len;
12013         uint8_t cipher_key[reference->cipher_key.len + 1];
12014         uint8_t auth_key[reference->auth_key.len + 1];
12015         struct rte_cryptodev_info dev_info;
12016
12017         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12018         uint64_t feat_flags = dev_info.feature_flags;
12019
12020         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12021                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12022                 printf("Device doesn't support RAW data-path APIs.\n");
12023                 return -ENOTSUP;
12024         }
12025
12026         /* Verify the capabilities */
12027         struct rte_cryptodev_sym_capability_idx cap_idx;
12028         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12029         cap_idx.algo.auth = reference->auth_algo;
12030         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12031                         &cap_idx) == NULL)
12032                 return -ENOTSUP;
12033         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12034         cap_idx.algo.cipher = reference->crypto_algo;
12035         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12036                         &cap_idx) == NULL)
12037                 return -ENOTSUP;
12038
12039         /* Create session */
12040         memcpy(cipher_key, reference->cipher_key.data,
12041                         reference->cipher_key.len);
12042         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12043
12044         /* Setup Cipher Parameters */
12045         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12046         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12047         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12048         ut_params->cipher_xform.cipher.key.data = cipher_key;
12049         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12050         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12051         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12052
12053         ut_params->cipher_xform.next = &ut_params->auth_xform;
12054
12055         /* Setup Authentication Parameters */
12056         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12057         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12058         ut_params->auth_xform.auth.algo = reference->auth_algo;
12059         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12060         ut_params->auth_xform.auth.key.data = auth_key;
12061         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12062         ut_params->auth_xform.next = NULL;
12063
12064         /* Create Crypto session*/
12065         ut_params->sess = rte_cryptodev_sym_session_create(
12066                         ts_params->session_mpool);
12067
12068         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12069                                 ut_params->sess,
12070                                 &ut_params->cipher_xform,
12071                                 ts_params->session_priv_mpool);
12072
12073         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12074
12075         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12076         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12077                         "Failed to allocate input buffer in mempool");
12078
12079         /* clear mbuf payload */
12080         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12081                         rte_pktmbuf_tailroom(ut_params->ibuf));
12082
12083         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12084                         reference->plaintext.len);
12085         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12086         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12087
12088         /* Create operation */
12089         retval = create_cipher_auth_operation(ts_params,
12090                         ut_params,
12091                         reference, 0);
12092
12093         if (retval < 0)
12094                 return retval;
12095
12096         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12097                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12098                         ut_params->op);
12099         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12100                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12101                                 ut_params->op, 1, 1, 0, 0);
12102         else
12103                 ut_params->op = process_crypto_request(
12104                         ts_params->valid_devs[0], ut_params->op);
12105
12106         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
12107
12108         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12109                         "crypto op processing failed");
12110
12111         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
12112
12113         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
12114                         ut_params->op->sym->auth.data.offset);
12115         auth_tag = authciphertext + plaintext_pad_len;
12116         debug_hexdump(stdout, "ciphertext:", authciphertext,
12117                         reference->ciphertext.len);
12118         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
12119
12120         /* Validate obuf */
12121         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12122                         authciphertext,
12123                         reference->ciphertext.data,
12124                         reference->ciphertext.len,
12125                         "Ciphertext data not as expected");
12126
12127         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12128                         auth_tag,
12129                         reference->digest.data,
12130                         reference->digest.len,
12131                         "Generated digest not as expected");
12132
12133         return TEST_SUCCESS;
12134
12135 }
12136
12137 static int
12138 test_authenticated_decrypt_with_esn(
12139                 struct crypto_testsuite_params *ts_params,
12140                 struct crypto_unittest_params *ut_params,
12141                 const struct test_crypto_vector *reference)
12142 {
12143         int retval;
12144
12145         uint8_t *ciphertext;
12146         uint8_t cipher_key[reference->cipher_key.len + 1];
12147         uint8_t auth_key[reference->auth_key.len + 1];
12148         struct rte_cryptodev_info dev_info;
12149
12150         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12151         uint64_t feat_flags = dev_info.feature_flags;
12152
12153         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12154                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12155                 printf("Device doesn't support RAW data-path APIs.\n");
12156                 return -ENOTSUP;
12157         }
12158
12159         /* Verify the capabilities */
12160         struct rte_cryptodev_sym_capability_idx cap_idx;
12161         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12162         cap_idx.algo.auth = reference->auth_algo;
12163         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12164                         &cap_idx) == NULL)
12165                 return -ENOTSUP;
12166         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12167         cap_idx.algo.cipher = reference->crypto_algo;
12168         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12169                         &cap_idx) == NULL)
12170                 return -ENOTSUP;
12171
12172         /* Create session */
12173         memcpy(cipher_key, reference->cipher_key.data,
12174                         reference->cipher_key.len);
12175         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12176
12177         /* Setup Authentication Parameters */
12178         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12179         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
12180         ut_params->auth_xform.auth.algo = reference->auth_algo;
12181         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12182         ut_params->auth_xform.auth.key.data = auth_key;
12183         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12184         ut_params->auth_xform.next = &ut_params->cipher_xform;
12185
12186         /* Setup Cipher Parameters */
12187         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12188         ut_params->cipher_xform.next = NULL;
12189         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12190         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
12191         ut_params->cipher_xform.cipher.key.data = cipher_key;
12192         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12193         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12194         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12195
12196         /* Create Crypto session*/
12197         ut_params->sess = rte_cryptodev_sym_session_create(
12198                         ts_params->session_mpool);
12199
12200         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12201                                 ut_params->sess,
12202                                 &ut_params->auth_xform,
12203                                 ts_params->session_priv_mpool);
12204
12205         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12206
12207         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12208         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12209                         "Failed to allocate input buffer in mempool");
12210
12211         /* clear mbuf payload */
12212         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12213                         rte_pktmbuf_tailroom(ut_params->ibuf));
12214
12215         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12216                         reference->ciphertext.len);
12217         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12218         memcpy(ciphertext, reference->ciphertext.data,
12219                         reference->ciphertext.len);
12220
12221         /* Create operation */
12222         retval = create_cipher_auth_verify_operation(ts_params,
12223                         ut_params,
12224                         reference);
12225
12226         if (retval < 0)
12227                 return retval;
12228
12229         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12230                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12231                         ut_params->op);
12232         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12233                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12234                                 ut_params->op, 1, 1, 0, 0);
12235         else
12236                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12237                         ut_params->op);
12238
12239         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
12240         TEST_ASSERT_EQUAL(ut_params->op->status,
12241                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12242                         "crypto op processing passed");
12243
12244         ut_params->obuf = ut_params->op->sym->m_src;
12245         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
12246
12247         return 0;
12248 }
12249
12250 static int
12251 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
12252                 const struct aead_test_data *tdata,
12253                 void *digest_mem, uint64_t digest_phys)
12254 {
12255         struct crypto_testsuite_params *ts_params = &testsuite_params;
12256         struct crypto_unittest_params *ut_params = &unittest_params;
12257
12258         const unsigned int auth_tag_len = tdata->auth_tag.len;
12259         const unsigned int iv_len = tdata->iv.len;
12260         unsigned int aad_len = tdata->aad.len;
12261         unsigned int aad_len_pad = 0;
12262
12263         /* Generate Crypto op data structure */
12264         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12265                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12266         TEST_ASSERT_NOT_NULL(ut_params->op,
12267                 "Failed to allocate symmetric crypto operation struct");
12268
12269         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12270
12271         sym_op->aead.digest.data = digest_mem;
12272
12273         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
12274                         "no room to append digest");
12275
12276         sym_op->aead.digest.phys_addr = digest_phys;
12277
12278         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
12279                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
12280                                 auth_tag_len);
12281                 debug_hexdump(stdout, "digest:",
12282                                 sym_op->aead.digest.data,
12283                                 auth_tag_len);
12284         }
12285
12286         /* Append aad data */
12287         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
12288                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12289                                 uint8_t *, IV_OFFSET);
12290
12291                 /* Copy IV 1 byte after the IV pointer, according to the API */
12292                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
12293
12294                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
12295
12296                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12297                                 ut_params->ibuf, aad_len);
12298                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12299                                 "no room to prepend aad");
12300                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12301                                 ut_params->ibuf);
12302
12303                 memset(sym_op->aead.aad.data, 0, aad_len);
12304                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
12305                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12306
12307                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12308                 debug_hexdump(stdout, "aad:",
12309                                 sym_op->aead.aad.data, aad_len);
12310         } else {
12311                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12312                                 uint8_t *, IV_OFFSET);
12313
12314                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
12315
12316                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
12317
12318                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12319                                 ut_params->ibuf, aad_len_pad);
12320                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12321                                 "no room to prepend aad");
12322                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12323                                 ut_params->ibuf);
12324
12325                 memset(sym_op->aead.aad.data, 0, aad_len);
12326                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12327
12328                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12329                 debug_hexdump(stdout, "aad:",
12330                                 sym_op->aead.aad.data, aad_len);
12331         }
12332
12333         sym_op->aead.data.length = tdata->plaintext.len;
12334         sym_op->aead.data.offset = aad_len_pad;
12335
12336         return 0;
12337 }
12338
12339 #define SGL_MAX_NO      16
12340
12341 static int
12342 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
12343                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
12344 {
12345         struct crypto_testsuite_params *ts_params = &testsuite_params;
12346         struct crypto_unittest_params *ut_params = &unittest_params;
12347         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
12348         int retval;
12349         int to_trn = 0;
12350         int to_trn_tbl[SGL_MAX_NO];
12351         int segs = 1;
12352         unsigned int trn_data = 0;
12353         uint8_t *plaintext, *ciphertext, *auth_tag;
12354         struct rte_cryptodev_info dev_info;
12355
12356         /* Verify the capabilities */
12357         struct rte_cryptodev_sym_capability_idx cap_idx;
12358         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
12359         cap_idx.algo.aead = tdata->algo;
12360         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12361                         &cap_idx) == NULL)
12362                 return -ENOTSUP;
12363
12364         /* OOP not supported with CPU crypto */
12365         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12366                 return -ENOTSUP;
12367
12368         /* Detailed check for the particular SGL support flag */
12369         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12370         if (!oop) {
12371                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12372                 if (sgl_in && (!(dev_info.feature_flags &
12373                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
12374                         return -ENOTSUP;
12375
12376                 uint64_t feat_flags = dev_info.feature_flags;
12377
12378                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12379                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12380                         printf("Device doesn't support RAW data-path APIs.\n");
12381                         return -ENOTSUP;
12382                 }
12383         } else {
12384                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12385                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
12386                                 tdata->plaintext.len;
12387                 /* Raw data path API does not support OOP */
12388                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12389                         return -ENOTSUP;
12390                 if (sgl_in && !sgl_out) {
12391                         if (!(dev_info.feature_flags &
12392                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
12393                                 return -ENOTSUP;
12394                 } else if (!sgl_in && sgl_out) {
12395                         if (!(dev_info.feature_flags &
12396                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
12397                                 return -ENOTSUP;
12398                 } else if (sgl_in && sgl_out) {
12399                         if (!(dev_info.feature_flags &
12400                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
12401                                 return -ENOTSUP;
12402                 }
12403         }
12404
12405         if (fragsz > tdata->plaintext.len)
12406                 fragsz = tdata->plaintext.len;
12407
12408         uint16_t plaintext_len = fragsz;
12409         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
12410
12411         if (fragsz_oop > tdata->plaintext.len)
12412                 frag_size_oop = tdata->plaintext.len;
12413
12414         int ecx = 0;
12415         void *digest_mem = NULL;
12416
12417         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
12418
12419         if (tdata->plaintext.len % fragsz != 0) {
12420                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
12421                         return 1;
12422         }       else {
12423                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
12424                         return 1;
12425         }
12426
12427         /*
12428          * For out-op-place we need to alloc another mbuf
12429          */
12430         if (oop) {
12431                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12432                 rte_pktmbuf_append(ut_params->obuf,
12433                                 frag_size_oop + prepend_len);
12434                 buf_oop = ut_params->obuf;
12435         }
12436
12437         /* Create AEAD session */
12438         retval = create_aead_session(ts_params->valid_devs[0],
12439                         tdata->algo,
12440                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
12441                         tdata->key.data, tdata->key.len,
12442                         tdata->aad.len, tdata->auth_tag.len,
12443                         tdata->iv.len);
12444         if (retval < 0)
12445                 return retval;
12446
12447         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12448
12449         /* clear mbuf payload */
12450         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12451                         rte_pktmbuf_tailroom(ut_params->ibuf));
12452
12453         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12454                         plaintext_len);
12455
12456         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12457
12458         trn_data += plaintext_len;
12459
12460         buf = ut_params->ibuf;
12461
12462         /*
12463          * Loop until no more fragments
12464          */
12465
12466         while (trn_data < tdata->plaintext.len) {
12467                 ++segs;
12468                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12469                                 (tdata->plaintext.len - trn_data) : fragsz;
12470
12471                 to_trn_tbl[ecx++] = to_trn;
12472
12473                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12474                 buf = buf->next;
12475
12476                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12477                                 rte_pktmbuf_tailroom(buf));
12478
12479                 /* OOP */
12480                 if (oop && !fragsz_oop) {
12481                         buf_last_oop = buf_oop->next =
12482                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12483                         buf_oop = buf_oop->next;
12484                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12485                                         0, rte_pktmbuf_tailroom(buf_oop));
12486                         rte_pktmbuf_append(buf_oop, to_trn);
12487                 }
12488
12489                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12490                                 to_trn);
12491
12492                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12493                                 to_trn);
12494                 trn_data += to_trn;
12495                 if (trn_data  == tdata->plaintext.len) {
12496                         if (oop) {
12497                                 if (!fragsz_oop)
12498                                         digest_mem = rte_pktmbuf_append(buf_oop,
12499                                                 tdata->auth_tag.len);
12500                         } else
12501                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12502                                         tdata->auth_tag.len);
12503                 }
12504         }
12505
12506         uint64_t digest_phys = 0;
12507
12508         ut_params->ibuf->nb_segs = segs;
12509
12510         segs = 1;
12511         if (fragsz_oop && oop) {
12512                 to_trn = 0;
12513                 ecx = 0;
12514
12515                 if (frag_size_oop == tdata->plaintext.len) {
12516                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
12517                                 tdata->auth_tag.len);
12518
12519                         digest_phys = rte_pktmbuf_iova_offset(
12520                                         ut_params->obuf,
12521                                         tdata->plaintext.len + prepend_len);
12522                 }
12523
12524                 trn_data = frag_size_oop;
12525                 while (trn_data < tdata->plaintext.len) {
12526                         ++segs;
12527                         to_trn =
12528                                 (tdata->plaintext.len - trn_data <
12529                                                 frag_size_oop) ?
12530                                 (tdata->plaintext.len - trn_data) :
12531                                                 frag_size_oop;
12532
12533                         to_trn_tbl[ecx++] = to_trn;
12534
12535                         buf_last_oop = buf_oop->next =
12536                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12537                         buf_oop = buf_oop->next;
12538                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12539                                         0, rte_pktmbuf_tailroom(buf_oop));
12540                         rte_pktmbuf_append(buf_oop, to_trn);
12541
12542                         trn_data += to_trn;
12543
12544                         if (trn_data  == tdata->plaintext.len) {
12545                                 digest_mem = rte_pktmbuf_append(buf_oop,
12546                                         tdata->auth_tag.len);
12547                         }
12548                 }
12549
12550                 ut_params->obuf->nb_segs = segs;
12551         }
12552
12553         /*
12554          * Place digest at the end of the last buffer
12555          */
12556         if (!digest_phys)
12557                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12558         if (oop && buf_last_oop)
12559                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
12560
12561         if (!digest_mem && !oop) {
12562                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12563                                 + tdata->auth_tag.len);
12564                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12565                                 tdata->plaintext.len);
12566         }
12567
12568         /* Create AEAD operation */
12569         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
12570                         tdata, digest_mem, digest_phys);
12571
12572         if (retval < 0)
12573                 return retval;
12574
12575         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12576
12577         ut_params->op->sym->m_src = ut_params->ibuf;
12578         if (oop)
12579                 ut_params->op->sym->m_dst = ut_params->obuf;
12580
12581         /* Process crypto operation */
12582         if (oop == IN_PLACE &&
12583                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12584                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
12585         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12586                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12587                                 ut_params->op, 0, 0, 0, 0);
12588         else
12589                 TEST_ASSERT_NOT_NULL(
12590                         process_crypto_request(ts_params->valid_devs[0],
12591                         ut_params->op), "failed to process sym crypto op");
12592
12593         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12594                         "crypto op processing failed");
12595
12596
12597         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
12598                         uint8_t *, prepend_len);
12599         if (oop) {
12600                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12601                                 uint8_t *, prepend_len);
12602         }
12603
12604         if (fragsz_oop)
12605                 fragsz = fragsz_oop;
12606
12607         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12608                         ciphertext,
12609                         tdata->ciphertext.data,
12610                         fragsz,
12611                         "Ciphertext data not as expected");
12612
12613         buf = ut_params->op->sym->m_src->next;
12614         if (oop)
12615                 buf = ut_params->op->sym->m_dst->next;
12616
12617         unsigned int off = fragsz;
12618
12619         ecx = 0;
12620         while (buf) {
12621                 ciphertext = rte_pktmbuf_mtod(buf,
12622                                 uint8_t *);
12623
12624                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12625                                 ciphertext,
12626                                 tdata->ciphertext.data + off,
12627                                 to_trn_tbl[ecx],
12628                                 "Ciphertext data not as expected");
12629
12630                 off += to_trn_tbl[ecx++];
12631                 buf = buf->next;
12632         }
12633
12634         auth_tag = digest_mem;
12635         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12636                         auth_tag,
12637                         tdata->auth_tag.data,
12638                         tdata->auth_tag.len,
12639                         "Generated auth tag not as expected");
12640
12641         return 0;
12642 }
12643
12644 static int
12645 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
12646 {
12647         return test_authenticated_encryption_SGL(
12648                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
12649 }
12650
12651 static int
12652 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
12653 {
12654         return test_authenticated_encryption_SGL(
12655                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
12656 }
12657
12658 static int
12659 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
12660 {
12661         return test_authenticated_encryption_SGL(
12662                         &gcm_test_case_8, OUT_OF_PLACE, 400,
12663                         gcm_test_case_8.plaintext.len);
12664 }
12665
12666 static int
12667 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
12668 {
12669         /* This test is not for OPENSSL PMD */
12670         if (gbl_driver_id == rte_cryptodev_driver_id_get(
12671                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
12672                 return -ENOTSUP;
12673
12674         return test_authenticated_encryption_SGL(
12675                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
12676 }
12677
12678 static int
12679 test_authentication_verify_fail_when_data_corrupted(
12680                 struct crypto_testsuite_params *ts_params,
12681                 struct crypto_unittest_params *ut_params,
12682                 const struct test_crypto_vector *reference)
12683 {
12684         return test_authentication_verify_fail_when_data_corruption(
12685                         ts_params, ut_params, reference, 1);
12686 }
12687
12688 static int
12689 test_authentication_verify_fail_when_tag_corrupted(
12690                 struct crypto_testsuite_params *ts_params,
12691                 struct crypto_unittest_params *ut_params,
12692                 const struct test_crypto_vector *reference)
12693 {
12694         return test_authentication_verify_fail_when_data_corruption(
12695                         ts_params, ut_params, reference, 0);
12696 }
12697
12698 static int
12699 test_authentication_verify_GMAC_fail_when_data_corrupted(
12700                 struct crypto_testsuite_params *ts_params,
12701                 struct crypto_unittest_params *ut_params,
12702                 const struct test_crypto_vector *reference)
12703 {
12704         return test_authentication_verify_GMAC_fail_when_corruption(
12705                         ts_params, ut_params, reference, 1);
12706 }
12707
12708 static int
12709 test_authentication_verify_GMAC_fail_when_tag_corrupted(
12710                 struct crypto_testsuite_params *ts_params,
12711                 struct crypto_unittest_params *ut_params,
12712                 const struct test_crypto_vector *reference)
12713 {
12714         return test_authentication_verify_GMAC_fail_when_corruption(
12715                         ts_params, ut_params, reference, 0);
12716 }
12717
12718 static int
12719 test_authenticated_decryption_fail_when_data_corrupted(
12720                 struct crypto_testsuite_params *ts_params,
12721                 struct crypto_unittest_params *ut_params,
12722                 const struct test_crypto_vector *reference)
12723 {
12724         return test_authenticated_decryption_fail_when_corruption(
12725                         ts_params, ut_params, reference, 1);
12726 }
12727
12728 static int
12729 test_authenticated_decryption_fail_when_tag_corrupted(
12730                 struct crypto_testsuite_params *ts_params,
12731                 struct crypto_unittest_params *ut_params,
12732                 const struct test_crypto_vector *reference)
12733 {
12734         return test_authenticated_decryption_fail_when_corruption(
12735                         ts_params, ut_params, reference, 0);
12736 }
12737
12738 static int
12739 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
12740 {
12741         return test_authentication_verify_fail_when_data_corrupted(
12742                         &testsuite_params, &unittest_params,
12743                         &hmac_sha1_test_crypto_vector);
12744 }
12745
12746 static int
12747 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
12748 {
12749         return test_authentication_verify_fail_when_tag_corrupted(
12750                         &testsuite_params, &unittest_params,
12751                         &hmac_sha1_test_crypto_vector);
12752 }
12753
12754 static int
12755 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
12756 {
12757         return test_authentication_verify_GMAC_fail_when_data_corrupted(
12758                         &testsuite_params, &unittest_params,
12759                         &aes128_gmac_test_vector);
12760 }
12761
12762 static int
12763 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
12764 {
12765         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
12766                         &testsuite_params, &unittest_params,
12767                         &aes128_gmac_test_vector);
12768 }
12769
12770 static int
12771 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
12772 {
12773         return test_authenticated_decryption_fail_when_data_corrupted(
12774                         &testsuite_params,
12775                         &unittest_params,
12776                         &aes128cbc_hmac_sha1_test_vector);
12777 }
12778
12779 static int
12780 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
12781 {
12782         return test_authenticated_decryption_fail_when_tag_corrupted(
12783                         &testsuite_params,
12784                         &unittest_params,
12785                         &aes128cbc_hmac_sha1_test_vector);
12786 }
12787
12788 static int
12789 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12790 {
12791         return test_authenticated_encryt_with_esn(
12792                         &testsuite_params,
12793                         &unittest_params,
12794                         &aes128cbc_hmac_sha1_aad_test_vector);
12795 }
12796
12797 static int
12798 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12799 {
12800         return test_authenticated_decrypt_with_esn(
12801                         &testsuite_params,
12802                         &unittest_params,
12803                         &aes128cbc_hmac_sha1_aad_test_vector);
12804 }
12805
12806 static int
12807 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
12808 {
12809         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
12810 }
12811
12812 static int
12813 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
12814 {
12815         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
12816 }
12817
12818 #ifdef RTE_CRYPTO_SCHEDULER
12819
12820 /* global AESNI worker IDs for the scheduler test */
12821 uint8_t aesni_ids[2];
12822
12823 static int
12824 test_scheduler_attach_slave_op(void)
12825 {
12826         struct crypto_testsuite_params *ts_params = &testsuite_params;
12827         uint8_t sched_id = ts_params->valid_devs[0];
12828         uint32_t nb_devs, i, nb_devs_attached = 0;
12829         int ret;
12830         char vdev_name[32];
12831
12832         /* create 2 AESNI_MB if necessary */
12833         nb_devs = rte_cryptodev_device_count_by_driver(
12834                         rte_cryptodev_driver_id_get(
12835                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
12836         if (nb_devs < 2) {
12837                 for (i = nb_devs; i < 2; i++) {
12838                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
12839                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
12840                                         i);
12841                         ret = rte_vdev_init(vdev_name, NULL);
12842
12843                         TEST_ASSERT(ret == 0,
12844                                 "Failed to create instance %u of"
12845                                 " pmd : %s",
12846                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12847                 }
12848         }
12849
12850         /* attach 2 AESNI_MB cdevs */
12851         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
12852                         i++) {
12853                 struct rte_cryptodev_info info;
12854                 unsigned int session_size;
12855
12856                 rte_cryptodev_info_get(i, &info);
12857                 if (info.driver_id != rte_cryptodev_driver_id_get(
12858                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
12859                         continue;
12860
12861                 session_size = rte_cryptodev_sym_get_private_session_size(i);
12862                 /*
12863                  * Create the session mempool again, since now there are new devices
12864                  * to use the mempool.
12865                  */
12866                 if (ts_params->session_mpool) {
12867                         rte_mempool_free(ts_params->session_mpool);
12868                         ts_params->session_mpool = NULL;
12869                 }
12870                 if (ts_params->session_priv_mpool) {
12871                         rte_mempool_free(ts_params->session_priv_mpool);
12872                         ts_params->session_priv_mpool = NULL;
12873                 }
12874
12875                 if (info.sym.max_nb_sessions != 0 &&
12876                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
12877                         RTE_LOG(ERR, USER1,
12878                                         "Device does not support "
12879                                         "at least %u sessions\n",
12880                                         MAX_NB_SESSIONS);
12881                         return TEST_FAILED;
12882                 }
12883                 /*
12884                  * Create mempool with maximum number of sessions,
12885                  * to include the session headers
12886                  */
12887                 if (ts_params->session_mpool == NULL) {
12888                         ts_params->session_mpool =
12889                                 rte_cryptodev_sym_session_pool_create(
12890                                                 "test_sess_mp",
12891                                                 MAX_NB_SESSIONS, 0, 0, 0,
12892                                                 SOCKET_ID_ANY);
12893                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
12894                                         "session mempool allocation failed");
12895                 }
12896
12897                 /*
12898                  * Create mempool with maximum number of sessions,
12899                  * to include device specific session private data
12900                  */
12901                 if (ts_params->session_priv_mpool == NULL) {
12902                         ts_params->session_priv_mpool = rte_mempool_create(
12903                                         "test_sess_mp_priv",
12904                                         MAX_NB_SESSIONS,
12905                                         session_size,
12906                                         0, 0, NULL, NULL, NULL,
12907                                         NULL, SOCKET_ID_ANY,
12908                                         0);
12909
12910                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
12911                                         "session mempool allocation failed");
12912                 }
12913
12914                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
12915                 ts_params->qp_conf.mp_session_private =
12916                                 ts_params->session_priv_mpool;
12917
12918                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
12919                                 (uint8_t)i);
12920
12921                 TEST_ASSERT(ret == 0,
12922                         "Failed to attach device %u of pmd : %s", i,
12923                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12924
12925                 aesni_ids[nb_devs_attached] = (uint8_t)i;
12926
12927                 nb_devs_attached++;
12928         }
12929
12930         return 0;
12931 }
12932
12933 static int
12934 test_scheduler_detach_slave_op(void)
12935 {
12936         struct crypto_testsuite_params *ts_params = &testsuite_params;
12937         uint8_t sched_id = ts_params->valid_devs[0];
12938         uint32_t i;
12939         int ret;
12940
12941         for (i = 0; i < 2; i++) {
12942                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
12943                                 aesni_ids[i]);
12944                 TEST_ASSERT(ret == 0,
12945                         "Failed to detach device %u", aesni_ids[i]);
12946         }
12947
12948         return 0;
12949 }
12950
12951 static int
12952 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
12953 {
12954         struct crypto_testsuite_params *ts_params = &testsuite_params;
12955         uint8_t sched_id = ts_params->valid_devs[0];
12956         /* set mode */
12957         return rte_cryptodev_scheduler_mode_set(sched_id,
12958                 scheduler_mode);
12959 }
12960
12961 static int
12962 test_scheduler_mode_roundrobin_op(void)
12963 {
12964         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
12965                         0, "Failed to set roundrobin mode");
12966         return 0;
12967
12968 }
12969
12970 static int
12971 test_scheduler_mode_multicore_op(void)
12972 {
12973         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
12974                         0, "Failed to set multicore mode");
12975
12976         return 0;
12977 }
12978
12979 static int
12980 test_scheduler_mode_failover_op(void)
12981 {
12982         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
12983                         0, "Failed to set failover mode");
12984
12985         return 0;
12986 }
12987
12988 static int
12989 test_scheduler_mode_pkt_size_distr_op(void)
12990 {
12991         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
12992                         0, "Failed to set pktsize mode");
12993
12994         return 0;
12995 }
12996
12997 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
12998         .suite_name = "Crypto Device Scheduler Unit Test Suite",
12999         .setup = testsuite_setup,
13000         .teardown = testsuite_teardown,
13001         .unit_test_cases = {
13002                 /* Multi Core */
13003                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13004                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
13005                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13006                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13007                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13008                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13009
13010                 /* Round Robin */
13011                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13012                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
13013                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13014                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13015                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13016                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13017
13018                 /* Fail over */
13019                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13020                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
13021                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13022                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13023                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13024                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13025
13026                 /* PKT SIZE */
13027                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13028                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
13029                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13030                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13031                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13032                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13033
13034                 TEST_CASES_END() /**< NULL terminate unit test array */
13035         }
13036 };
13037
13038 #endif /* RTE_CRYPTO_SCHEDULER */
13039
13040 static struct unit_test_suite cryptodev_testsuite  = {
13041         .suite_name = "Crypto Unit Test Suite",
13042         .setup = testsuite_setup,
13043         .teardown = testsuite_teardown,
13044         .unit_test_cases = {
13045                 TEST_CASE_ST(ut_setup, ut_teardown,
13046                                 test_device_configure_invalid_dev_id),
13047                 TEST_CASE_ST(ut_setup, ut_teardown,
13048                                 test_queue_pair_descriptor_setup),
13049                 TEST_CASE_ST(ut_setup, ut_teardown,
13050                                 test_device_configure_invalid_queue_pair_ids),
13051
13052                 TEST_CASE_ST(ut_setup, ut_teardown,
13053                                 test_multi_session),
13054                 TEST_CASE_ST(ut_setup, ut_teardown,
13055                                 test_multi_session_random_usage),
13056
13057                 TEST_CASE_ST(ut_setup, ut_teardown,
13058                         test_null_invalid_operation),
13059                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
13060
13061                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13062                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13063                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13064                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13065                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
13066                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
13067                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
13068                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13069                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
13070
13071                 /** AES CCM Authenticated Encryption 128 bits key */
13072                 TEST_CASE_ST(ut_setup, ut_teardown,
13073                         test_AES_CCM_authenticated_encryption_test_case_128_1),
13074                 TEST_CASE_ST(ut_setup, ut_teardown,
13075                         test_AES_CCM_authenticated_encryption_test_case_128_2),
13076                 TEST_CASE_ST(ut_setup, ut_teardown,
13077                         test_AES_CCM_authenticated_encryption_test_case_128_3),
13078
13079                 /** AES CCM Authenticated Decryption 128 bits key*/
13080                 TEST_CASE_ST(ut_setup, ut_teardown,
13081                         test_AES_CCM_authenticated_decryption_test_case_128_1),
13082                 TEST_CASE_ST(ut_setup, ut_teardown,
13083                         test_AES_CCM_authenticated_decryption_test_case_128_2),
13084                 TEST_CASE_ST(ut_setup, ut_teardown,
13085                         test_AES_CCM_authenticated_decryption_test_case_128_3),
13086
13087                 /** AES CCM Authenticated Encryption 192 bits key */
13088                 TEST_CASE_ST(ut_setup, ut_teardown,
13089                         test_AES_CCM_authenticated_encryption_test_case_192_1),
13090                 TEST_CASE_ST(ut_setup, ut_teardown,
13091                         test_AES_CCM_authenticated_encryption_test_case_192_2),
13092                 TEST_CASE_ST(ut_setup, ut_teardown,
13093                         test_AES_CCM_authenticated_encryption_test_case_192_3),
13094
13095                 /** AES CCM Authenticated Decryption 192 bits key*/
13096                 TEST_CASE_ST(ut_setup, ut_teardown,
13097                         test_AES_CCM_authenticated_decryption_test_case_192_1),
13098                 TEST_CASE_ST(ut_setup, ut_teardown,
13099                         test_AES_CCM_authenticated_decryption_test_case_192_2),
13100                 TEST_CASE_ST(ut_setup, ut_teardown,
13101                         test_AES_CCM_authenticated_decryption_test_case_192_3),
13102
13103                 /** AES CCM Authenticated Encryption 256 bits key */
13104                 TEST_CASE_ST(ut_setup, ut_teardown,
13105                         test_AES_CCM_authenticated_encryption_test_case_256_1),
13106                 TEST_CASE_ST(ut_setup, ut_teardown,
13107                         test_AES_CCM_authenticated_encryption_test_case_256_2),
13108                 TEST_CASE_ST(ut_setup, ut_teardown,
13109                         test_AES_CCM_authenticated_encryption_test_case_256_3),
13110
13111                 /** AES CCM Authenticated Decryption 256 bits key*/
13112                 TEST_CASE_ST(ut_setup, ut_teardown,
13113                         test_AES_CCM_authenticated_decryption_test_case_256_1),
13114                 TEST_CASE_ST(ut_setup, ut_teardown,
13115                         test_AES_CCM_authenticated_decryption_test_case_256_2),
13116                 TEST_CASE_ST(ut_setup, ut_teardown,
13117                         test_AES_CCM_authenticated_decryption_test_case_256_3),
13118
13119                 /** AES GCM Authenticated Encryption */
13120                 TEST_CASE_ST(ut_setup, ut_teardown,
13121                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13122                 TEST_CASE_ST(ut_setup, ut_teardown,
13123                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13124                 TEST_CASE_ST(ut_setup, ut_teardown,
13125                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13126                 TEST_CASE_ST(ut_setup, ut_teardown,
13127                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13128                 TEST_CASE_ST(ut_setup, ut_teardown,
13129                         test_AES_GCM_authenticated_encryption_test_case_1),
13130                 TEST_CASE_ST(ut_setup, ut_teardown,
13131                         test_AES_GCM_authenticated_encryption_test_case_2),
13132                 TEST_CASE_ST(ut_setup, ut_teardown,
13133                         test_AES_GCM_authenticated_encryption_test_case_3),
13134                 TEST_CASE_ST(ut_setup, ut_teardown,
13135                         test_AES_GCM_authenticated_encryption_test_case_4),
13136                 TEST_CASE_ST(ut_setup, ut_teardown,
13137                         test_AES_GCM_authenticated_encryption_test_case_5),
13138                 TEST_CASE_ST(ut_setup, ut_teardown,
13139                         test_AES_GCM_authenticated_encryption_test_case_6),
13140                 TEST_CASE_ST(ut_setup, ut_teardown,
13141                         test_AES_GCM_authenticated_encryption_test_case_7),
13142                 TEST_CASE_ST(ut_setup, ut_teardown,
13143                         test_AES_GCM_authenticated_encryption_test_case_8),
13144                 TEST_CASE_ST(ut_setup, ut_teardown,
13145                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
13146
13147                 /** AES GCM Authenticated Decryption */
13148                 TEST_CASE_ST(ut_setup, ut_teardown,
13149                         test_AES_GCM_authenticated_decryption_test_case_1),
13150                 TEST_CASE_ST(ut_setup, ut_teardown,
13151                         test_AES_GCM_authenticated_decryption_test_case_2),
13152                 TEST_CASE_ST(ut_setup, ut_teardown,
13153                         test_AES_GCM_authenticated_decryption_test_case_3),
13154                 TEST_CASE_ST(ut_setup, ut_teardown,
13155                         test_AES_GCM_authenticated_decryption_test_case_4),
13156                 TEST_CASE_ST(ut_setup, ut_teardown,
13157                         test_AES_GCM_authenticated_decryption_test_case_5),
13158                 TEST_CASE_ST(ut_setup, ut_teardown,
13159                         test_AES_GCM_authenticated_decryption_test_case_6),
13160                 TEST_CASE_ST(ut_setup, ut_teardown,
13161                         test_AES_GCM_authenticated_decryption_test_case_7),
13162                 TEST_CASE_ST(ut_setup, ut_teardown,
13163                         test_AES_GCM_authenticated_decryption_test_case_8),
13164                 TEST_CASE_ST(ut_setup, ut_teardown,
13165                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
13166
13167                 /** AES GCM Authenticated Encryption 192 bits key */
13168                 TEST_CASE_ST(ut_setup, ut_teardown,
13169                         test_AES_GCM_auth_encryption_test_case_192_1),
13170                 TEST_CASE_ST(ut_setup, ut_teardown,
13171                         test_AES_GCM_auth_encryption_test_case_192_2),
13172                 TEST_CASE_ST(ut_setup, ut_teardown,
13173                         test_AES_GCM_auth_encryption_test_case_192_3),
13174                 TEST_CASE_ST(ut_setup, ut_teardown,
13175                         test_AES_GCM_auth_encryption_test_case_192_4),
13176                 TEST_CASE_ST(ut_setup, ut_teardown,
13177                         test_AES_GCM_auth_encryption_test_case_192_5),
13178                 TEST_CASE_ST(ut_setup, ut_teardown,
13179                         test_AES_GCM_auth_encryption_test_case_192_6),
13180                 TEST_CASE_ST(ut_setup, ut_teardown,
13181                         test_AES_GCM_auth_encryption_test_case_192_7),
13182
13183                 /** AES GCM Authenticated Decryption 192 bits key */
13184                 TEST_CASE_ST(ut_setup, ut_teardown,
13185                         test_AES_GCM_auth_decryption_test_case_192_1),
13186                 TEST_CASE_ST(ut_setup, ut_teardown,
13187                         test_AES_GCM_auth_decryption_test_case_192_2),
13188                 TEST_CASE_ST(ut_setup, ut_teardown,
13189                         test_AES_GCM_auth_decryption_test_case_192_3),
13190                 TEST_CASE_ST(ut_setup, ut_teardown,
13191                         test_AES_GCM_auth_decryption_test_case_192_4),
13192                 TEST_CASE_ST(ut_setup, ut_teardown,
13193                         test_AES_GCM_auth_decryption_test_case_192_5),
13194                 TEST_CASE_ST(ut_setup, ut_teardown,
13195                         test_AES_GCM_auth_decryption_test_case_192_6),
13196                 TEST_CASE_ST(ut_setup, ut_teardown,
13197                         test_AES_GCM_auth_decryption_test_case_192_7),
13198
13199                 /** AES GCM Authenticated Encryption 256 bits key */
13200                 TEST_CASE_ST(ut_setup, ut_teardown,
13201                         test_AES_GCM_auth_encryption_test_case_256_1),
13202                 TEST_CASE_ST(ut_setup, ut_teardown,
13203                         test_AES_GCM_auth_encryption_test_case_256_2),
13204                 TEST_CASE_ST(ut_setup, ut_teardown,
13205                         test_AES_GCM_auth_encryption_test_case_256_3),
13206                 TEST_CASE_ST(ut_setup, ut_teardown,
13207                         test_AES_GCM_auth_encryption_test_case_256_4),
13208                 TEST_CASE_ST(ut_setup, ut_teardown,
13209                         test_AES_GCM_auth_encryption_test_case_256_5),
13210                 TEST_CASE_ST(ut_setup, ut_teardown,
13211                         test_AES_GCM_auth_encryption_test_case_256_6),
13212                 TEST_CASE_ST(ut_setup, ut_teardown,
13213                         test_AES_GCM_auth_encryption_test_case_256_7),
13214
13215                 /** AES GCM Authenticated Decryption 256 bits key */
13216                 TEST_CASE_ST(ut_setup, ut_teardown,
13217                         test_AES_GCM_auth_decryption_test_case_256_1),
13218                 TEST_CASE_ST(ut_setup, ut_teardown,
13219                         test_AES_GCM_auth_decryption_test_case_256_2),
13220                 TEST_CASE_ST(ut_setup, ut_teardown,
13221                         test_AES_GCM_auth_decryption_test_case_256_3),
13222                 TEST_CASE_ST(ut_setup, ut_teardown,
13223                         test_AES_GCM_auth_decryption_test_case_256_4),
13224                 TEST_CASE_ST(ut_setup, ut_teardown,
13225                         test_AES_GCM_auth_decryption_test_case_256_5),
13226                 TEST_CASE_ST(ut_setup, ut_teardown,
13227                         test_AES_GCM_auth_decryption_test_case_256_6),
13228                 TEST_CASE_ST(ut_setup, ut_teardown,
13229                         test_AES_GCM_auth_decryption_test_case_256_7),
13230
13231                 /** AES GCM Authenticated Encryption big aad size */
13232                 TEST_CASE_ST(ut_setup, ut_teardown,
13233                         test_AES_GCM_auth_encryption_test_case_aad_1),
13234                 TEST_CASE_ST(ut_setup, ut_teardown,
13235                         test_AES_GCM_auth_encryption_test_case_aad_2),
13236
13237                 /** AES GCM Authenticated Decryption big aad size */
13238                 TEST_CASE_ST(ut_setup, ut_teardown,
13239                         test_AES_GCM_auth_decryption_test_case_aad_1),
13240                 TEST_CASE_ST(ut_setup, ut_teardown,
13241                         test_AES_GCM_auth_decryption_test_case_aad_2),
13242
13243                 /** Out of place tests */
13244                 TEST_CASE_ST(ut_setup, ut_teardown,
13245                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13246                 TEST_CASE_ST(ut_setup, ut_teardown,
13247                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13248
13249                 /** Session-less tests */
13250                 TEST_CASE_ST(ut_setup, ut_teardown,
13251                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13252                 TEST_CASE_ST(ut_setup, ut_teardown,
13253                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13254
13255                 /** AES GMAC Authentication */
13256                 TEST_CASE_ST(ut_setup, ut_teardown,
13257                         test_AES_GMAC_authentication_test_case_1),
13258                 TEST_CASE_ST(ut_setup, ut_teardown,
13259                         test_AES_GMAC_authentication_verify_test_case_1),
13260                 TEST_CASE_ST(ut_setup, ut_teardown,
13261                         test_AES_GMAC_authentication_test_case_2),
13262                 TEST_CASE_ST(ut_setup, ut_teardown,
13263                         test_AES_GMAC_authentication_verify_test_case_2),
13264                 TEST_CASE_ST(ut_setup, ut_teardown,
13265                         test_AES_GMAC_authentication_test_case_3),
13266                 TEST_CASE_ST(ut_setup, ut_teardown,
13267                         test_AES_GMAC_authentication_verify_test_case_3),
13268                 TEST_CASE_ST(ut_setup, ut_teardown,
13269                         test_AES_GMAC_authentication_test_case_4),
13270                 TEST_CASE_ST(ut_setup, ut_teardown,
13271                         test_AES_GMAC_authentication_verify_test_case_4),
13272                 TEST_CASE_ST(ut_setup, ut_teardown,
13273                         test_AES_GMAC_authentication_SGL_40B),
13274                 TEST_CASE_ST(ut_setup, ut_teardown,
13275                         test_AES_GMAC_authentication_SGL_80B),
13276                 TEST_CASE_ST(ut_setup, ut_teardown,
13277                         test_AES_GMAC_authentication_SGL_2048B),
13278                 TEST_CASE_ST(ut_setup, ut_teardown,
13279                         test_AES_GMAC_authentication_SGL_2047B),
13280
13281                 /** Chacha20-Poly1305 */
13282                 TEST_CASE_ST(ut_setup, ut_teardown,
13283                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
13284                 TEST_CASE_ST(ut_setup, ut_teardown,
13285                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
13286                 /** SNOW 3G encrypt only (UEA2) */
13287                 TEST_CASE_ST(ut_setup, ut_teardown,
13288                         test_snow3g_encryption_test_case_1),
13289                 TEST_CASE_ST(ut_setup, ut_teardown,
13290                         test_snow3g_encryption_test_case_2),
13291                 TEST_CASE_ST(ut_setup, ut_teardown,
13292                         test_snow3g_encryption_test_case_3),
13293                 TEST_CASE_ST(ut_setup, ut_teardown,
13294                         test_snow3g_encryption_test_case_4),
13295                 TEST_CASE_ST(ut_setup, ut_teardown,
13296                         test_snow3g_encryption_test_case_5),
13297
13298                 TEST_CASE_ST(ut_setup, ut_teardown,
13299                         test_snow3g_encryption_test_case_1_oop),
13300                 TEST_CASE_ST(ut_setup, ut_teardown,
13301                         test_snow3g_encryption_test_case_1_oop_sgl),
13302                 TEST_CASE_ST(ut_setup, ut_teardown,
13303                         test_snow3g_encryption_test_case_1_offset_oop),
13304                 TEST_CASE_ST(ut_setup, ut_teardown,
13305                         test_snow3g_decryption_test_case_1_oop),
13306
13307                 /** SNOW 3G generate auth, then encrypt (UEA2) */
13308                 TEST_CASE_ST(ut_setup, ut_teardown,
13309                         test_snow3g_auth_cipher_test_case_1),
13310                 TEST_CASE_ST(ut_setup, ut_teardown,
13311                         test_snow3g_auth_cipher_test_case_2),
13312                 TEST_CASE_ST(ut_setup, ut_teardown,
13313                         test_snow3g_auth_cipher_test_case_2_oop),
13314                 TEST_CASE_ST(ut_setup, ut_teardown,
13315                         test_snow3g_auth_cipher_part_digest_enc),
13316                 TEST_CASE_ST(ut_setup, ut_teardown,
13317                         test_snow3g_auth_cipher_part_digest_enc_oop),
13318                 TEST_CASE_ST(ut_setup, ut_teardown,
13319                         test_snow3g_auth_cipher_test_case_3_sgl),
13320                 TEST_CASE_ST(ut_setup, ut_teardown,
13321                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
13322                 TEST_CASE_ST(ut_setup, ut_teardown,
13323                         test_snow3g_auth_cipher_part_digest_enc_sgl),
13324                 TEST_CASE_ST(ut_setup, ut_teardown,
13325                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
13326
13327                 /** SNOW 3G decrypt (UEA2), then verify auth */
13328                 TEST_CASE_ST(ut_setup, ut_teardown,
13329                         test_snow3g_auth_cipher_verify_test_case_1),
13330                 TEST_CASE_ST(ut_setup, ut_teardown,
13331                         test_snow3g_auth_cipher_verify_test_case_2),
13332                 TEST_CASE_ST(ut_setup, ut_teardown,
13333                         test_snow3g_auth_cipher_verify_test_case_2_oop),
13334                 TEST_CASE_ST(ut_setup, ut_teardown,
13335                         test_snow3g_auth_cipher_verify_part_digest_enc),
13336                 TEST_CASE_ST(ut_setup, ut_teardown,
13337                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
13338                 TEST_CASE_ST(ut_setup, ut_teardown,
13339                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
13340                 TEST_CASE_ST(ut_setup, ut_teardown,
13341                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
13342                 TEST_CASE_ST(ut_setup, ut_teardown,
13343                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
13344                 TEST_CASE_ST(ut_setup, ut_teardown,
13345                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
13346
13347                 /** SNOW 3G decrypt only (UEA2) */
13348                 TEST_CASE_ST(ut_setup, ut_teardown,
13349                         test_snow3g_decryption_test_case_1),
13350                 TEST_CASE_ST(ut_setup, ut_teardown,
13351                         test_snow3g_decryption_test_case_2),
13352                 TEST_CASE_ST(ut_setup, ut_teardown,
13353                         test_snow3g_decryption_test_case_3),
13354                 TEST_CASE_ST(ut_setup, ut_teardown,
13355                         test_snow3g_decryption_test_case_4),
13356                 TEST_CASE_ST(ut_setup, ut_teardown,
13357                         test_snow3g_decryption_test_case_5),
13358                 TEST_CASE_ST(ut_setup, ut_teardown,
13359                         test_snow3g_decryption_with_digest_test_case_1),
13360                 TEST_CASE_ST(ut_setup, ut_teardown,
13361                         test_snow3g_hash_generate_test_case_1),
13362                 TEST_CASE_ST(ut_setup, ut_teardown,
13363                         test_snow3g_hash_generate_test_case_2),
13364                 TEST_CASE_ST(ut_setup, ut_teardown,
13365                         test_snow3g_hash_generate_test_case_3),
13366                 /* Tests with buffers which length is not byte-aligned */
13367                 TEST_CASE_ST(ut_setup, ut_teardown,
13368                         test_snow3g_hash_generate_test_case_4),
13369                 TEST_CASE_ST(ut_setup, ut_teardown,
13370                         test_snow3g_hash_generate_test_case_5),
13371                 TEST_CASE_ST(ut_setup, ut_teardown,
13372                         test_snow3g_hash_generate_test_case_6),
13373                 TEST_CASE_ST(ut_setup, ut_teardown,
13374                         test_snow3g_hash_verify_test_case_1),
13375                 TEST_CASE_ST(ut_setup, ut_teardown,
13376                         test_snow3g_hash_verify_test_case_2),
13377                 TEST_CASE_ST(ut_setup, ut_teardown,
13378                         test_snow3g_hash_verify_test_case_3),
13379                 /* Tests with buffers which length is not byte-aligned */
13380                 TEST_CASE_ST(ut_setup, ut_teardown,
13381                         test_snow3g_hash_verify_test_case_4),
13382                 TEST_CASE_ST(ut_setup, ut_teardown,
13383                         test_snow3g_hash_verify_test_case_5),
13384                 TEST_CASE_ST(ut_setup, ut_teardown,
13385                         test_snow3g_hash_verify_test_case_6),
13386                 TEST_CASE_ST(ut_setup, ut_teardown,
13387                         test_snow3g_cipher_auth_test_case_1),
13388                 TEST_CASE_ST(ut_setup, ut_teardown,
13389                         test_snow3g_auth_cipher_with_digest_test_case_1),
13390
13391                 /** ZUC encrypt only (EEA3) */
13392                 TEST_CASE_ST(ut_setup, ut_teardown,
13393                         test_zuc_encryption_test_case_1),
13394                 TEST_CASE_ST(ut_setup, ut_teardown,
13395                         test_zuc_encryption_test_case_2),
13396                 TEST_CASE_ST(ut_setup, ut_teardown,
13397                         test_zuc_encryption_test_case_3),
13398                 TEST_CASE_ST(ut_setup, ut_teardown,
13399                         test_zuc_encryption_test_case_4),
13400                 TEST_CASE_ST(ut_setup, ut_teardown,
13401                         test_zuc_encryption_test_case_5),
13402                 TEST_CASE_ST(ut_setup, ut_teardown,
13403                         test_zuc_encryption_test_case_6_sgl),
13404
13405                 /** ZUC authenticate (EIA3) */
13406                 TEST_CASE_ST(ut_setup, ut_teardown,
13407                         test_zuc_hash_generate_test_case_1),
13408                 TEST_CASE_ST(ut_setup, ut_teardown,
13409                         test_zuc_hash_generate_test_case_2),
13410                 TEST_CASE_ST(ut_setup, ut_teardown,
13411                         test_zuc_hash_generate_test_case_3),
13412                 TEST_CASE_ST(ut_setup, ut_teardown,
13413                         test_zuc_hash_generate_test_case_4),
13414                 TEST_CASE_ST(ut_setup, ut_teardown,
13415                         test_zuc_hash_generate_test_case_5),
13416                 TEST_CASE_ST(ut_setup, ut_teardown,
13417                         test_zuc_hash_generate_test_case_6),
13418                 TEST_CASE_ST(ut_setup, ut_teardown,
13419                         test_zuc_hash_generate_test_case_7),
13420                 TEST_CASE_ST(ut_setup, ut_teardown,
13421                         test_zuc_hash_generate_test_case_8),
13422
13423                 /** ZUC alg-chain (EEA3/EIA3) */
13424                 TEST_CASE_ST(ut_setup, ut_teardown,
13425                         test_zuc_cipher_auth_test_case_1),
13426                 TEST_CASE_ST(ut_setup, ut_teardown,
13427                         test_zuc_cipher_auth_test_case_2),
13428
13429                 /** ZUC generate auth, then encrypt (EEA3) */
13430                 TEST_CASE_ST(ut_setup, ut_teardown,
13431                         test_zuc_auth_cipher_test_case_1),
13432                 TEST_CASE_ST(ut_setup, ut_teardown,
13433                         test_zuc_auth_cipher_test_case_1_oop),
13434                 TEST_CASE_ST(ut_setup, ut_teardown,
13435                         test_zuc_auth_cipher_test_case_1_sgl),
13436                 TEST_CASE_ST(ut_setup, ut_teardown,
13437                         test_zuc_auth_cipher_test_case_1_oop_sgl),
13438
13439                 /** ZUC decrypt (EEA3), then verify auth */
13440                 TEST_CASE_ST(ut_setup, ut_teardown,
13441                         test_zuc_auth_cipher_verify_test_case_1),
13442                 TEST_CASE_ST(ut_setup, ut_teardown,
13443                         test_zuc_auth_cipher_verify_test_case_1_oop),
13444                 TEST_CASE_ST(ut_setup, ut_teardown,
13445                         test_zuc_auth_cipher_verify_test_case_1_sgl),
13446                 TEST_CASE_ST(ut_setup, ut_teardown,
13447                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
13448
13449                 /** HMAC_MD5 Authentication */
13450                 TEST_CASE_ST(ut_setup, ut_teardown,
13451                         test_MD5_HMAC_generate_case_1),
13452                 TEST_CASE_ST(ut_setup, ut_teardown,
13453                         test_MD5_HMAC_verify_case_1),
13454                 TEST_CASE_ST(ut_setup, ut_teardown,
13455                         test_MD5_HMAC_generate_case_2),
13456                 TEST_CASE_ST(ut_setup, ut_teardown,
13457                         test_MD5_HMAC_verify_case_2),
13458
13459                 /** KASUMI hash only (UIA1) */
13460                 TEST_CASE_ST(ut_setup, ut_teardown,
13461                         test_kasumi_hash_generate_test_case_1),
13462                 TEST_CASE_ST(ut_setup, ut_teardown,
13463                         test_kasumi_hash_generate_test_case_2),
13464                 TEST_CASE_ST(ut_setup, ut_teardown,
13465                         test_kasumi_hash_generate_test_case_3),
13466                 TEST_CASE_ST(ut_setup, ut_teardown,
13467                         test_kasumi_hash_generate_test_case_4),
13468                 TEST_CASE_ST(ut_setup, ut_teardown,
13469                         test_kasumi_hash_generate_test_case_5),
13470                 TEST_CASE_ST(ut_setup, ut_teardown,
13471                         test_kasumi_hash_generate_test_case_6),
13472
13473                 TEST_CASE_ST(ut_setup, ut_teardown,
13474                         test_kasumi_hash_verify_test_case_1),
13475                 TEST_CASE_ST(ut_setup, ut_teardown,
13476                         test_kasumi_hash_verify_test_case_2),
13477                 TEST_CASE_ST(ut_setup, ut_teardown,
13478                         test_kasumi_hash_verify_test_case_3),
13479                 TEST_CASE_ST(ut_setup, ut_teardown,
13480                         test_kasumi_hash_verify_test_case_4),
13481                 TEST_CASE_ST(ut_setup, ut_teardown,
13482                         test_kasumi_hash_verify_test_case_5),
13483
13484                 /** KASUMI encrypt only (UEA1) */
13485                 TEST_CASE_ST(ut_setup, ut_teardown,
13486                         test_kasumi_encryption_test_case_1),
13487                 TEST_CASE_ST(ut_setup, ut_teardown,
13488                         test_kasumi_encryption_test_case_1_sgl),
13489                 TEST_CASE_ST(ut_setup, ut_teardown,
13490                         test_kasumi_encryption_test_case_1_oop),
13491                 TEST_CASE_ST(ut_setup, ut_teardown,
13492                         test_kasumi_encryption_test_case_1_oop_sgl),
13493                 TEST_CASE_ST(ut_setup, ut_teardown,
13494                         test_kasumi_encryption_test_case_2),
13495                 TEST_CASE_ST(ut_setup, ut_teardown,
13496                         test_kasumi_encryption_test_case_3),
13497                 TEST_CASE_ST(ut_setup, ut_teardown,
13498                         test_kasumi_encryption_test_case_4),
13499                 TEST_CASE_ST(ut_setup, ut_teardown,
13500                         test_kasumi_encryption_test_case_5),
13501
13502                 /** KASUMI decrypt only (UEA1) */
13503                 TEST_CASE_ST(ut_setup, ut_teardown,
13504                         test_kasumi_decryption_test_case_1),
13505                 TEST_CASE_ST(ut_setup, ut_teardown,
13506                         test_kasumi_decryption_test_case_2),
13507                 TEST_CASE_ST(ut_setup, ut_teardown,
13508                         test_kasumi_decryption_test_case_3),
13509                 TEST_CASE_ST(ut_setup, ut_teardown,
13510                         test_kasumi_decryption_test_case_4),
13511                 TEST_CASE_ST(ut_setup, ut_teardown,
13512                         test_kasumi_decryption_test_case_5),
13513                 TEST_CASE_ST(ut_setup, ut_teardown,
13514                         test_kasumi_decryption_test_case_1_oop),
13515
13516                 TEST_CASE_ST(ut_setup, ut_teardown,
13517                         test_kasumi_cipher_auth_test_case_1),
13518
13519                 /** KASUMI generate auth, then encrypt (F8) */
13520                 TEST_CASE_ST(ut_setup, ut_teardown,
13521                         test_kasumi_auth_cipher_test_case_1),
13522                 TEST_CASE_ST(ut_setup, ut_teardown,
13523                         test_kasumi_auth_cipher_test_case_2),
13524                 TEST_CASE_ST(ut_setup, ut_teardown,
13525                         test_kasumi_auth_cipher_test_case_2_oop),
13526                 TEST_CASE_ST(ut_setup, ut_teardown,
13527                         test_kasumi_auth_cipher_test_case_2_sgl),
13528                 TEST_CASE_ST(ut_setup, ut_teardown,
13529                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
13530
13531                 /** KASUMI decrypt (F8), then verify auth */
13532                 TEST_CASE_ST(ut_setup, ut_teardown,
13533                         test_kasumi_auth_cipher_verify_test_case_1),
13534                 TEST_CASE_ST(ut_setup, ut_teardown,
13535                         test_kasumi_auth_cipher_verify_test_case_2),
13536                 TEST_CASE_ST(ut_setup, ut_teardown,
13537                         test_kasumi_auth_cipher_verify_test_case_2_oop),
13538                 TEST_CASE_ST(ut_setup, ut_teardown,
13539                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
13540                 TEST_CASE_ST(ut_setup, ut_teardown,
13541                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
13542
13543                 /** ESN Testcase */
13544                 TEST_CASE_ST(ut_setup, ut_teardown,
13545                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13546                 TEST_CASE_ST(ut_setup, ut_teardown,
13547                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13548
13549                 /** Negative tests */
13550                 TEST_CASE_ST(ut_setup, ut_teardown,
13551                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13552                 TEST_CASE_ST(ut_setup, ut_teardown,
13553                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13554                 TEST_CASE_ST(ut_setup, ut_teardown,
13555                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
13556                 TEST_CASE_ST(ut_setup, ut_teardown,
13557                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13558                 TEST_CASE_ST(ut_setup, ut_teardown,
13559                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13560                 TEST_CASE_ST(ut_setup, ut_teardown,
13561                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13562                 TEST_CASE_ST(ut_setup, ut_teardown,
13563                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
13564                 TEST_CASE_ST(ut_setup, ut_teardown,
13565                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
13566                 TEST_CASE_ST(ut_setup, ut_teardown,
13567                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
13568                 TEST_CASE_ST(ut_setup, ut_teardown,
13569                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13570                 TEST_CASE_ST(ut_setup, ut_teardown,
13571                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13572                 TEST_CASE_ST(ut_setup, ut_teardown,
13573                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13574                 TEST_CASE_ST(ut_setup, ut_teardown,
13575                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
13576                 TEST_CASE_ST(ut_setup, ut_teardown,
13577                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
13578                 TEST_CASE_ST(ut_setup, ut_teardown,
13579                         authentication_verify_AES128_GMAC_fail_data_corrupt),
13580                 TEST_CASE_ST(ut_setup, ut_teardown,
13581                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
13582                 TEST_CASE_ST(ut_setup, ut_teardown,
13583                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13584                 TEST_CASE_ST(ut_setup, ut_teardown,
13585                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13586
13587                 /** Mixed CIPHER + HASH algorithms */
13588                 /** AUTH AES CMAC + CIPHER AES CTR */
13589                 TEST_CASE_ST(ut_setup, ut_teardown,
13590                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
13591                 TEST_CASE_ST(ut_setup, ut_teardown,
13592                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13593                 TEST_CASE_ST(ut_setup, ut_teardown,
13594                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13595                 TEST_CASE_ST(ut_setup, ut_teardown,
13596                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13597                 TEST_CASE_ST(ut_setup, ut_teardown,
13598                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
13599                 TEST_CASE_ST(ut_setup, ut_teardown,
13600                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13601                 TEST_CASE_ST(ut_setup, ut_teardown,
13602                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13603                 TEST_CASE_ST(ut_setup, ut_teardown,
13604                    test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13605
13606                 /** AUTH ZUC + CIPHER SNOW3G */
13607                 TEST_CASE_ST(ut_setup, ut_teardown,
13608                         test_auth_zuc_cipher_snow_test_case_1),
13609                 TEST_CASE_ST(ut_setup, ut_teardown,
13610                         test_verify_auth_zuc_cipher_snow_test_case_1),
13611                 /** AUTH AES CMAC + CIPHER SNOW3G */
13612                 TEST_CASE_ST(ut_setup, ut_teardown,
13613                         test_auth_aes_cmac_cipher_snow_test_case_1),
13614                 TEST_CASE_ST(ut_setup, ut_teardown,
13615                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
13616                 /** AUTH ZUC + CIPHER AES CTR */
13617                 TEST_CASE_ST(ut_setup, ut_teardown,
13618                         test_auth_zuc_cipher_aes_ctr_test_case_1),
13619                 TEST_CASE_ST(ut_setup, ut_teardown,
13620                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
13621                 /** AUTH SNOW3G + CIPHER AES CTR */
13622                 TEST_CASE_ST(ut_setup, ut_teardown,
13623                         test_auth_snow_cipher_aes_ctr_test_case_1),
13624                 TEST_CASE_ST(ut_setup, ut_teardown,
13625                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
13626                 /** AUTH SNOW3G + CIPHER ZUC */
13627                 TEST_CASE_ST(ut_setup, ut_teardown,
13628                         test_auth_snow_cipher_zuc_test_case_1),
13629                 TEST_CASE_ST(ut_setup, ut_teardown,
13630                         test_verify_auth_snow_cipher_zuc_test_case_1),
13631                 /** AUTH AES CMAC + CIPHER ZUC */
13632                 TEST_CASE_ST(ut_setup, ut_teardown,
13633                         test_auth_aes_cmac_cipher_zuc_test_case_1),
13634                 TEST_CASE_ST(ut_setup, ut_teardown,
13635                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
13636
13637                 /** AUTH NULL + CIPHER SNOW3G */
13638                 TEST_CASE_ST(ut_setup, ut_teardown,
13639                         test_auth_null_cipher_snow_test_case_1),
13640                 TEST_CASE_ST(ut_setup, ut_teardown,
13641                         test_verify_auth_null_cipher_snow_test_case_1),
13642                 /** AUTH NULL + CIPHER ZUC */
13643                 TEST_CASE_ST(ut_setup, ut_teardown,
13644                         test_auth_null_cipher_zuc_test_case_1),
13645                 TEST_CASE_ST(ut_setup, ut_teardown,
13646                         test_verify_auth_null_cipher_zuc_test_case_1),
13647                 /** AUTH SNOW3G + CIPHER NULL */
13648                 TEST_CASE_ST(ut_setup, ut_teardown,
13649                         test_auth_snow_cipher_null_test_case_1),
13650                 TEST_CASE_ST(ut_setup, ut_teardown,
13651                         test_verify_auth_snow_cipher_null_test_case_1),
13652                 /** AUTH ZUC + CIPHER NULL */
13653                 TEST_CASE_ST(ut_setup, ut_teardown,
13654                         test_auth_zuc_cipher_null_test_case_1),
13655                 TEST_CASE_ST(ut_setup, ut_teardown,
13656                         test_verify_auth_zuc_cipher_null_test_case_1),
13657                 /** AUTH NULL + CIPHER AES CTR */
13658                 TEST_CASE_ST(ut_setup, ut_teardown,
13659                         test_auth_null_cipher_aes_ctr_test_case_1),
13660                 TEST_CASE_ST(ut_setup, ut_teardown,
13661                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
13662                 /** AUTH AES CMAC + CIPHER NULL */
13663                 TEST_CASE_ST(ut_setup, ut_teardown,
13664                         test_auth_aes_cmac_cipher_null_test_case_1),
13665                 TEST_CASE_ST(ut_setup, ut_teardown,
13666                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
13667
13668 #ifdef RTE_LIB_SECURITY
13669                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13670                         test_PDCP_PROTO_all),
13671                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13672                         test_DOCSIS_PROTO_all),
13673 #endif
13674                 TEST_CASES_END() /**< NULL terminate unit test array */
13675         }
13676 };
13677
13678 static struct unit_test_suite cryptodev_virtio_testsuite = {
13679         .suite_name = "Crypto VIRTIO Unit Test Suite",
13680         .setup = testsuite_setup,
13681         .teardown = testsuite_teardown,
13682         .unit_test_cases = {
13683                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13684
13685                 TEST_CASES_END() /**< NULL terminate unit test array */
13686         }
13687 };
13688
13689 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
13690         .suite_name = "Crypto CAAM JR Unit Test Suite",
13691         .setup = testsuite_setup,
13692         .teardown = testsuite_teardown,
13693         .unit_test_cases = {
13694                 TEST_CASE_ST(ut_setup, ut_teardown,
13695                              test_device_configure_invalid_dev_id),
13696                 TEST_CASE_ST(ut_setup, ut_teardown,
13697                              test_multi_session),
13698
13699                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13700                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13701                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13702                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13703                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13704
13705                 TEST_CASES_END() /**< NULL terminate unit test array */
13706         }
13707 };
13708
13709 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
13710         .suite_name = "Crypto Device Marvell Component Test Suite",
13711         .setup = testsuite_setup,
13712         .teardown = testsuite_teardown,
13713         .unit_test_cases = {
13714                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13715                 TEST_CASE_ST(ut_setup, ut_teardown,
13716                                 test_multi_session_random_usage),
13717                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13718                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13719                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13720                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13721                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13722
13723                 /** Negative tests */
13724                 TEST_CASE_ST(ut_setup, ut_teardown,
13725                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13726                 TEST_CASE_ST(ut_setup, ut_teardown,
13727                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13728                 TEST_CASE_ST(ut_setup, ut_teardown,
13729                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13730                 TEST_CASE_ST(ut_setup, ut_teardown,
13731                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13732
13733                 TEST_CASES_END() /**< NULL terminate unit test array */
13734         }
13735 };
13736
13737 static struct unit_test_suite cryptodev_ccp_testsuite  = {
13738         .suite_name = "Crypto Device CCP Unit Test Suite",
13739         .setup = testsuite_setup,
13740         .teardown = testsuite_teardown,
13741         .unit_test_cases = {
13742                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13743                 TEST_CASE_ST(ut_setup, ut_teardown,
13744                                 test_multi_session_random_usage),
13745                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13746                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13747                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13748                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13749                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13750
13751                 /** Negative tests */
13752                 TEST_CASE_ST(ut_setup, ut_teardown,
13753                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13754                 TEST_CASE_ST(ut_setup, ut_teardown,
13755                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13756                 TEST_CASE_ST(ut_setup, ut_teardown,
13757                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13758                 TEST_CASE_ST(ut_setup, ut_teardown,
13759                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13760
13761                 TEST_CASES_END() /**< NULL terminate unit test array */
13762         }
13763 };
13764
13765 static int
13766 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
13767 {
13768         gbl_driver_id = rte_cryptodev_driver_id_get(
13769                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
13770
13771         if (gbl_driver_id == -1) {
13772                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
13773                 return TEST_SKIPPED;
13774         }
13775
13776         return unit_test_suite_runner(&cryptodev_testsuite);
13777 }
13778
13779 static int
13780 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
13781 {
13782         gbl_driver_id = rte_cryptodev_driver_id_get(
13783                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
13784
13785         if (gbl_driver_id == -1) {
13786                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded.\n");
13787                 return TEST_FAILED;
13788         }
13789
13790         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
13791 }
13792
13793 static int
13794 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
13795 {
13796         gbl_driver_id = rte_cryptodev_driver_id_get(
13797                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13798
13799         if (gbl_driver_id == -1) {
13800                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13801                 return TEST_SKIPPED;
13802         }
13803
13804         return unit_test_suite_runner(&cryptodev_testsuite);
13805 }
13806
13807 static int
13808 test_cryptodev_cpu_aesni_mb(void)
13809 {
13810         int32_t rc;
13811         enum rte_security_session_action_type at;
13812
13813         gbl_driver_id = rte_cryptodev_driver_id_get(
13814                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13815
13816         if (gbl_driver_id == -1) {
13817                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13818                 return TEST_SKIPPED;
13819         }
13820
13821         at = gbl_action_type;
13822         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13823         rc = unit_test_suite_runner(&cryptodev_testsuite);
13824         gbl_action_type = at;
13825         return rc;
13826 }
13827
13828 static int
13829 test_cryptodev_openssl(void)
13830 {
13831         gbl_driver_id = rte_cryptodev_driver_id_get(
13832                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
13833
13834         if (gbl_driver_id == -1) {
13835                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
13836                 return TEST_SKIPPED;
13837         }
13838
13839         return unit_test_suite_runner(&cryptodev_testsuite);
13840 }
13841
13842 static int
13843 test_cryptodev_aesni_gcm(void)
13844 {
13845         gbl_driver_id = rte_cryptodev_driver_id_get(
13846                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13847
13848         if (gbl_driver_id == -1) {
13849                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13850                 return TEST_SKIPPED;
13851         }
13852
13853         return unit_test_suite_runner(&cryptodev_testsuite);
13854 }
13855
13856 static int
13857 test_cryptodev_cpu_aesni_gcm(void)
13858 {
13859         int32_t rc;
13860         enum rte_security_session_action_type at;
13861
13862         gbl_driver_id = rte_cryptodev_driver_id_get(
13863                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13864
13865         if (gbl_driver_id == -1) {
13866                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13867                 return TEST_SKIPPED;
13868         }
13869
13870         at = gbl_action_type;
13871         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13872         rc = unit_test_suite_runner(&cryptodev_testsuite);
13873         gbl_action_type = at;
13874         return rc;
13875 }
13876
13877 static int
13878 test_cryptodev_null(void)
13879 {
13880         gbl_driver_id = rte_cryptodev_driver_id_get(
13881                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
13882
13883         if (gbl_driver_id == -1) {
13884                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded.\n");
13885                 return TEST_SKIPPED;
13886         }
13887
13888         return unit_test_suite_runner(&cryptodev_testsuite);
13889 }
13890
13891 static int
13892 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
13893 {
13894         gbl_driver_id = rte_cryptodev_driver_id_get(
13895                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
13896
13897         if (gbl_driver_id == -1) {
13898                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded.\n");
13899                 return TEST_SKIPPED;
13900         }
13901
13902         return unit_test_suite_runner(&cryptodev_testsuite);
13903 }
13904
13905 static int
13906 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
13907 {
13908         gbl_driver_id = rte_cryptodev_driver_id_get(
13909                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
13910
13911         if (gbl_driver_id == -1) {
13912                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13913                 return TEST_SKIPPED;
13914         }
13915
13916         return unit_test_suite_runner(&cryptodev_testsuite);
13917 }
13918
13919 static int
13920 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
13921 {
13922         gbl_driver_id = rte_cryptodev_driver_id_get(
13923                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
13924
13925         if (gbl_driver_id == -1) {
13926                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13927                 return TEST_SKIPPED;
13928         }
13929
13930         return unit_test_suite_runner(&cryptodev_testsuite);
13931 }
13932
13933 static int
13934 test_cryptodev_armv8(void)
13935 {
13936         gbl_driver_id = rte_cryptodev_driver_id_get(
13937                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
13938
13939         if (gbl_driver_id == -1) {
13940                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded.\n");
13941                 return TEST_SKIPPED;
13942         }
13943
13944         return unit_test_suite_runner(&cryptodev_testsuite);
13945 }
13946
13947 static int
13948 test_cryptodev_mrvl(void)
13949 {
13950         gbl_driver_id = rte_cryptodev_driver_id_get(
13951                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
13952
13953         if (gbl_driver_id == -1) {
13954                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded.\n");
13955                 return TEST_SKIPPED;
13956         }
13957
13958         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
13959 }
13960
13961 #ifdef RTE_CRYPTO_SCHEDULER
13962
13963 static int
13964 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
13965 {
13966         gbl_driver_id = rte_cryptodev_driver_id_get(
13967                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13968
13969         if (gbl_driver_id == -1) {
13970                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
13971                 return TEST_SKIPPED;
13972         }
13973
13974         if (rte_cryptodev_driver_id_get(
13975                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
13976                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13977                 return TEST_SKIPPED;
13978 }
13979         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
13980 }
13981
13982 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
13983
13984 #endif
13985
13986 static int
13987 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13988 {
13989         gbl_driver_id = rte_cryptodev_driver_id_get(
13990                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
13991
13992         if (gbl_driver_id == -1) {
13993                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded.\n");
13994                 return TEST_SKIPPED;
13995         }
13996
13997         return unit_test_suite_runner(&cryptodev_testsuite);
13998 }
13999
14000 static int
14001 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14002 {
14003         gbl_driver_id = rte_cryptodev_driver_id_get(
14004                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14005
14006         if (gbl_driver_id == -1) {
14007                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded.\n");
14008                 return TEST_SKIPPED;
14009         }
14010
14011         return unit_test_suite_runner(&cryptodev_testsuite);
14012 }
14013
14014 static int
14015 test_cryptodev_ccp(void)
14016 {
14017         gbl_driver_id = rte_cryptodev_driver_id_get(
14018                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14019
14020         if (gbl_driver_id == -1) {
14021                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded.\n");
14022                 return TEST_FAILED;
14023         }
14024
14025         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
14026 }
14027
14028 static int
14029 test_cryptodev_octeontx(void)
14030 {
14031         gbl_driver_id = rte_cryptodev_driver_id_get(
14032                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14033         if (gbl_driver_id == -1) {
14034                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
14035                 return TEST_FAILED;
14036         }
14037         return unit_test_suite_runner(&cryptodev_testsuite);
14038 }
14039
14040 static int
14041 test_cryptodev_octeontx2(void)
14042 {
14043         gbl_driver_id = rte_cryptodev_driver_id_get(
14044                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14045         if (gbl_driver_id == -1) {
14046                 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded.\n");
14047                 return TEST_FAILED;
14048         }
14049         return unit_test_suite_runner(&cryptodev_testsuite);
14050 }
14051
14052 static int
14053 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
14054 {
14055         gbl_driver_id = rte_cryptodev_driver_id_get(
14056                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14057
14058         if (gbl_driver_id == -1) {
14059                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded.\n");
14060                 return TEST_FAILED;
14061         }
14062
14063         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
14064 }
14065
14066 static int
14067 test_cryptodev_nitrox(void)
14068 {
14069         gbl_driver_id = rte_cryptodev_driver_id_get(
14070                         RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14071
14072         if (gbl_driver_id == -1) {
14073                 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded.\n");
14074                 return TEST_FAILED;
14075         }
14076
14077         return unit_test_suite_runner(&cryptodev_testsuite);
14078 }
14079
14080 static int
14081 test_cryptodev_bcmfs(void)
14082 {
14083         gbl_driver_id = rte_cryptodev_driver_id_get(
14084                         RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
14085
14086         if (gbl_driver_id == -1) {
14087                 RTE_LOG(ERR, USER1, "BCMFS PMD must be loaded.\n");
14088                 return TEST_FAILED;
14089         }
14090
14091         return unit_test_suite_runner(&cryptodev_testsuite);
14092 }
14093
14094 static int
14095 test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
14096 {
14097         int ret;
14098
14099         gbl_driver_id = rte_cryptodev_driver_id_get(
14100                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14101
14102         if (gbl_driver_id == -1) {
14103                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
14104                 return TEST_SKIPPED;
14105         }
14106
14107         global_api_test_type = CRYPTODEV_RAW_API_TEST;
14108         ret = unit_test_suite_runner(&cryptodev_testsuite);
14109         global_api_test_type = CRYPTODEV_API_TEST;
14110
14111         return ret;
14112 }
14113
14114 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
14115                 test_cryptodev_qat_raw_api);
14116 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14117 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14118 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
14119         test_cryptodev_cpu_aesni_mb);
14120 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14121 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14122 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
14123         test_cryptodev_cpu_aesni_gcm);
14124 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14125 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14126 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14127 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14128 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14129 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14130 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14131 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14132 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14133 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14134 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14135 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14136 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14137 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
14138 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);