app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #include <time.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_hexdump.h>
  10 #include <rte_mbuf.h>
  11 #include <rte_malloc.h>
  12 #include <rte_memcpy.h>
  13 #include <rte_pause.h>
  14 #include <rte_bus_vdev.h>
  15 #include <rte_ether.h>
  16
  17 #include <rte_crypto.h>
  18 #include <rte_cryptodev.h>
  19 #include <rte_cryptodev_pmd.h>
  20 #include <rte_string_fns.h>
  21
  22 #ifdef RTE_CRYPTO_SCHEDULER
  23 #include <rte_cryptodev_scheduler.h>
  24 #include <rte_cryptodev_scheduler_operations.h>
  25 #endif
  26
  27 #include <rte_lcore.h>
  28
  29 #include "test.h"
  30 #include "test_cryptodev.h"
  31
  32 #include "test_cryptodev_blockcipher.h"
  33 #include "test_cryptodev_aes_test_vectors.h"
  34 #include "test_cryptodev_des_test_vectors.h"
  35 #include "test_cryptodev_hash_test_vectors.h"
  36 #include "test_cryptodev_kasumi_test_vectors.h"
  37 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  38 #include "test_cryptodev_snow3g_test_vectors.h"
  39 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  40 #include "test_cryptodev_zuc_test_vectors.h"
  41 #include "test_cryptodev_aead_test_vectors.h"
  42 #include "test_cryptodev_hmac_test_vectors.h"
  43 #include "test_cryptodev_mixed_test_vectors.h"
  44 #ifdef RTE_LIB_SECURITY
  45 #include "test_cryptodev_security_pdcp_test_vectors.h"
  46 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  47 #include "test_cryptodev_security_pdcp_test_func.h"
  48 #include "test_cryptodev_security_docsis_test_vectors.h"
  49
  50 #define SDAP_DISABLED   0
  51 #define SDAP_ENABLED    1
  52 #endif
  53
  54 #define VDEV_ARGS_SIZE 100
  55 #define MAX_NB_SESSIONS 4
  56
  57 #define MAX_DRV_SERVICE_CTX_SIZE 256
  58
  59 #define MAX_RAW_DEQUEUE_COUNT   65535
  60
  61 #define IN_PLACE 0
  62 #define OUT_OF_PLACE 1
  63
  64 #ifndef ARRAY_SIZE
  65 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  66 #endif
  67
  68 static int gbl_driver_id;
  69
  70 static enum rte_security_session_action_type gbl_action_type =
  71         RTE_SECURITY_ACTION_TYPE_NONE;
  72
  73 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  74
  75 struct crypto_testsuite_params {
  76         struct rte_mempool *mbuf_pool;
  77         struct rte_mempool *large_mbuf_pool;
  78         struct rte_mempool *op_mpool;
  79         struct rte_mempool *session_mpool;
  80         struct rte_mempool *session_priv_mpool;
  81         struct rte_cryptodev_config conf;
  82         struct rte_cryptodev_qp_conf qp_conf;
  83
  84         uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS];
  85         uint8_t valid_dev_count;
  86 };
  87
  88 struct crypto_unittest_params {
  89         struct rte_crypto_sym_xform cipher_xform;
  90         struct rte_crypto_sym_xform auth_xform;
  91         struct rte_crypto_sym_xform aead_xform;
  92 #ifdef RTE_LIB_SECURITY
  93         struct rte_security_docsis_xform docsis_xform;
  94 #endif
  95
  96         union {
  97                 struct rte_cryptodev_sym_session *sess;
  98 #ifdef RTE_LIB_SECURITY
  99                 struct rte_security_session *sec_session;
 100 #endif
 101         };
 102 #ifdef RTE_LIB_SECURITY
 103         enum rte_security_session_action_type type;
 104 #endif
 105         struct rte_crypto_op *op;
 106
 107         struct rte_mbuf *obuf, *ibuf;
 108
 109         uint8_t *digest;
 110 };
 111
 112 #define ALIGN_POW2_ROUNDUP(num, align) \
 113         (((num) + (align) - 1) & ~((align) - 1))
 114
 115 /*
 116  * Forward declarations.
 117  */
 118 static int
 119 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 120                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 121                 uint8_t *hmac_key);
 122
 123 static int
 124 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 125                 struct crypto_unittest_params *ut_params,
 126                 struct crypto_testsuite_params *ts_param,
 127                 const uint8_t *cipher,
 128                 const uint8_t *digest,
 129                 const uint8_t *iv);
 130
 131 static struct rte_mbuf *
 132 setup_test_string(struct rte_mempool *mpool,
 133                 const char *string, size_t len, uint8_t blocksize)
 134 {
 135         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 136         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 137
 138         memset(m->buf_addr, 0, m->buf_len);
 139         if (m) {
 140                 char *dst = rte_pktmbuf_append(m, t_len);
 141
 142                 if (!dst) {
 143                         rte_pktmbuf_free(m);
 144                         return NULL;
 145                 }
 146                 if (string != NULL)
 147                         rte_memcpy(dst, string, t_len);
 148                 else
 149                         memset(dst, 0, t_len);
 150         }
 151
 152         return m;
 153 }
 154
 155 /* Get number of bytes in X bits (rounding up) */
 156 static uint32_t
 157 ceil_byte_length(uint32_t num_bits)
 158 {
 159         if (num_bits % 8)
 160                 return ((num_bits >> 3) + 1);
 161         else
 162                 return (num_bits >> 3);
 163 }
 164
 165 static uint32_t
 166 get_raw_dp_dequeue_count(void *user_data __rte_unused)
 167 {
 168         return 1;
 169 }
 170
 171 static void
 172 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 173                 uint8_t is_op_success)
 174 {
 175         struct rte_crypto_op *op = user_data;
 176         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 177                         RTE_CRYPTO_OP_STATUS_ERROR;
 178 }
 179
 180 void
 181 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 182                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 183                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 184 {
 185         struct rte_crypto_sym_op *sop = op->sym;
 186         struct rte_crypto_op *ret_op = NULL;
 187         struct rte_crypto_vec data_vec[UINT8_MAX];
 188         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 189         union rte_crypto_sym_ofs ofs;
 190         struct rte_crypto_sym_vec vec;
 191         struct rte_crypto_sgl sgl;
 192         uint32_t max_len;
 193         union rte_cryptodev_session_ctx sess;
 194         uint32_t count = 0;
 195         struct rte_crypto_raw_dp_ctx *ctx;
 196         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 197                         auth_len = 0;
 198         int32_t n;
 199         uint32_t n_success;
 200         int ctx_service_size;
 201         int32_t status = 0;
 202         int enqueue_status, dequeue_status;
 203
 204         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 205         if (ctx_service_size < 0) {
 206                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 207                 return;
 208         }
 209
 210         ctx = malloc(ctx_service_size);
 211         if (!ctx) {
 212                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 213                 return;
 214         }
 215
 216         /* Both are enums, setting crypto_sess will suit any session type */
 217         sess.crypto_sess = op->sym->session;
 218
 219         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 220                         op->sess_type, sess, 0) < 0) {
 221                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 222                 goto exit;
 223         }
 224
 225         cipher_iv.iova = 0;
 226         cipher_iv.va = NULL;
 227         aad_auth_iv.iova = 0;
 228         aad_auth_iv.va = NULL;
 229         digest.iova = 0;
 230         digest.va = NULL;
 231         sgl.vec = data_vec;
 232         vec.num = 1;
 233         vec.sgl = &sgl;
 234         vec.iv = &cipher_iv;
 235         vec.digest = &digest;
 236         vec.aad = &aad_auth_iv;
 237         vec.status = &status;
 238
 239         ofs.raw = 0;
 240
 241         if (is_cipher && is_auth) {
 242                 cipher_offset = sop->cipher.data.offset;
 243                 cipher_len = sop->cipher.data.length;
 244                 auth_offset = sop->auth.data.offset;
 245                 auth_len = sop->auth.data.length;
 246                 max_len = RTE_MAX(cipher_offset + cipher_len,
 247                                 auth_offset + auth_len);
 248                 if (len_in_bits) {
 249                         max_len = max_len >> 3;
 250                         cipher_offset = cipher_offset >> 3;
 251                         auth_offset = auth_offset >> 3;
 252                         cipher_len = cipher_len >> 3;
 253                         auth_len = auth_len >> 3;
 254                 }
 255                 ofs.ofs.cipher.head = cipher_offset;
 256                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 257                 ofs.ofs.auth.head = auth_offset;
 258                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 259                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 260                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 261                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 262                                 op, void *, IV_OFFSET + cipher_iv_len);
 263                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 264                                 cipher_iv_len);
 265                 digest.va = (void *)sop->auth.digest.data;
 266                 digest.iova = sop->auth.digest.phys_addr;
 267
 268         } else if (is_cipher) {
 269                 cipher_offset = sop->cipher.data.offset;
 270                 cipher_len = sop->cipher.data.length;
 271                 max_len = cipher_len + cipher_offset;
 272                 if (len_in_bits) {
 273                         max_len = max_len >> 3;
 274                         cipher_offset = cipher_offset >> 3;
 275                         cipher_len = cipher_len >> 3;
 276                 }
 277                 ofs.ofs.cipher.head = cipher_offset;
 278                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 279                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 280                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 281
 282         } else if (is_auth) {
 283                 auth_offset = sop->auth.data.offset;
 284                 auth_len = sop->auth.data.length;
 285                 max_len = auth_len + auth_offset;
 286                 if (len_in_bits) {
 287                         max_len = max_len >> 3;
 288                         auth_offset = auth_offset >> 3;
 289                         auth_len = auth_len >> 3;
 290                 }
 291                 ofs.ofs.auth.head = auth_offset;
 292                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 293                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 294                                 op, void *, IV_OFFSET + cipher_iv_len);
 295                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 296                                 cipher_iv_len);
 297                 digest.va = (void *)sop->auth.digest.data;
 298                 digest.iova = sop->auth.digest.phys_addr;
 299
 300         } else { /* aead */
 301                 cipher_offset = sop->aead.data.offset;
 302                 cipher_len = sop->aead.data.length;
 303                 max_len = cipher_len + cipher_offset;
 304                 if (len_in_bits) {
 305                         max_len = max_len >> 3;
 306                         cipher_offset = cipher_offset >> 3;
 307                         cipher_len = cipher_len >> 3;
 308                 }
 309                 ofs.ofs.cipher.head = cipher_offset;
 310                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 311                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 312                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 313                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 314                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 315                 digest.va = (void *)sop->aead.digest.data;
 316                 digest.iova = sop->aead.digest.phys_addr;
 317         }
 318
 319         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 320                         data_vec, RTE_DIM(data_vec));
 321         if (n < 0 || n > sop->m_src->nb_segs) {
 322                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 323                 goto exit;
 324         }
 325
 326         sgl.num = n;
 327
 328         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 329                         &enqueue_status) < 1) {
 330                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 331                 goto exit;
 332         }
 333
 334         if (enqueue_status == 0) {
 335                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 336                 if (status < 0) {
 337                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 338                         goto exit;
 339                 }
 340         } else if (enqueue_status < 0) {
 341                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 342                 goto exit;
 343         }
 344
 345         n = n_success = 0;
 346         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 347                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 348                         get_raw_dp_dequeue_count, post_process_raw_dp_op,
 349                                 (void **)&ret_op, 0, &n_success,
 350                                 &dequeue_status);
 351                 if (dequeue_status < 0) {
 352                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 353                         goto exit;
 354                 }
 355                 if (n == 0)
 356                         rte_pause();
 357         }
 358
 359         if (n == 1 && dequeue_status == 0) {
 360                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 361                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 362                         goto exit;
 363                 }
 364         }
 365
 366         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 367                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 368                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 369
 370 exit:
 371         free(ctx);
 372 }
 373
 374 static void
 375 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 376 {
 377         int32_t n, st;
 378         struct rte_crypto_sym_op *sop;
 379         union rte_crypto_sym_ofs ofs;
 380         struct rte_crypto_sgl sgl;
 381         struct rte_crypto_sym_vec symvec;
 382         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 383         struct rte_crypto_vec vec[UINT8_MAX];
 384
 385         sop = op->sym;
 386
 387         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 388                 sop->aead.data.length, vec, RTE_DIM(vec));
 389
 390         if (n < 0 || n != sop->m_src->nb_segs) {
 391                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 392                 return;
 393         }
 394
 395         sgl.vec = vec;
 396         sgl.num = n;
 397         symvec.sgl = &sgl;
 398         symvec.iv = &iv_ptr;
 399         symvec.digest = &digest_ptr;
 400         symvec.aad = &aad_ptr;
 401         symvec.status = &st;
 402         symvec.num = 1;
 403
 404         /* for CPU crypto the IOVA address is not required */
 405         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 406         digest_ptr.va = (void *)sop->aead.digest.data;
 407         aad_ptr.va = (void *)sop->aead.aad.data;
 408
 409         ofs.raw = 0;
 410
 411         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 412                 &symvec);
 413
 414         if (n != 1)
 415                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 416         else
 417                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 418 }
 419
 420 static void
 421 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 422 {
 423         int32_t n, st;
 424         struct rte_crypto_sym_op *sop;
 425         union rte_crypto_sym_ofs ofs;
 426         struct rte_crypto_sgl sgl;
 427         struct rte_crypto_sym_vec symvec;
 428         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 429         struct rte_crypto_vec vec[UINT8_MAX];
 430
 431         sop = op->sym;
 432
 433         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 434                 sop->auth.data.length, vec, RTE_DIM(vec));
 435
 436         if (n < 0 || n != sop->m_src->nb_segs) {
 437                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 438                 return;
 439         }
 440
 441         sgl.vec = vec;
 442         sgl.num = n;
 443         symvec.sgl = &sgl;
 444         symvec.iv = &iv_ptr;
 445         symvec.digest = &digest_ptr;
 446         symvec.status = &st;
 447         symvec.num = 1;
 448
 449         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 450         digest_ptr.va = (void *)sop->auth.digest.data;
 451
 452         ofs.raw = 0;
 453         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 454         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 455                 (sop->cipher.data.offset + sop->cipher.data.length);
 456
 457         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 458                 &symvec);
 459
 460         if (n != 1)
 461                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 462         else
 463                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 464 }
 465
 466 static struct rte_crypto_op *
 467 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 468 {
 469
 470         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 471
 472         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 473                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 474                 return NULL;
 475         }
 476
 477         op = NULL;
 478
 479         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 480                 rte_pause();
 481
 482         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 483                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 484                 return NULL;
 485         }
 486
 487         return op;
 488 }
 489
 490 static struct crypto_testsuite_params testsuite_params = { NULL };
 491 static struct crypto_unittest_params unittest_params;
 492
 493 static int
 494 testsuite_setup(void)
 495 {
 496         struct crypto_testsuite_params *ts_params = &testsuite_params;
 497         struct rte_cryptodev_info info;
 498         uint32_t i = 0, nb_devs, dev_id;
 499         int ret;
 500         uint16_t qp_id;
 501
 502         memset(ts_params, 0, sizeof(*ts_params));
 503
 504         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 505         if (ts_params->mbuf_pool == NULL) {
 506                 /* Not already created so create */
 507                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 508                                 "CRYPTO_MBUFPOOL",
 509                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 510                                 rte_socket_id());
 511                 if (ts_params->mbuf_pool == NULL) {
 512                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 513                         return TEST_FAILED;
 514                 }
 515         }
 516
 517         ts_params->large_mbuf_pool = rte_mempool_lookup(
 518                         "CRYPTO_LARGE_MBUFPOOL");
 519         if (ts_params->large_mbuf_pool == NULL) {
 520                 /* Not already created so create */
 521                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 522                                 "CRYPTO_LARGE_MBUFPOOL",
 523                                 1, 0, 0, UINT16_MAX,
 524                                 rte_socket_id());
 525                 if (ts_params->large_mbuf_pool == NULL) {
 526                         RTE_LOG(ERR, USER1,
 527                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 528                         return TEST_FAILED;
 529                 }
 530         }
 531
 532         ts_params->op_mpool = rte_crypto_op_pool_create(
 533                         "MBUF_CRYPTO_SYM_OP_POOL",
 534                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 535                         NUM_MBUFS, MBUF_CACHE_SIZE,
 536                         DEFAULT_NUM_XFORMS *
 537                         sizeof(struct rte_crypto_sym_xform) +
 538                         MAXIMUM_IV_LENGTH,
 539                         rte_socket_id());
 540         if (ts_params->op_mpool == NULL) {
 541                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 542                 return TEST_FAILED;
 543         }
 544
 545         /* Create an AESNI MB device if required */
 546         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 547                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
 548                 nb_devs = rte_cryptodev_device_count_by_driver(
 549                                 rte_cryptodev_driver_id_get(
 550                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
 551                 if (nb_devs < 1) {
 552                         ret = rte_vdev_init(
 553                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
 554
 555                         TEST_ASSERT(ret == 0,
 556                                 "Failed to create instance of"
 557                                 " pmd : %s",
 558                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
 559                 }
 560         }
 561
 562         /* Create an AESNI GCM device if required */
 563         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 564                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
 565                 nb_devs = rte_cryptodev_device_count_by_driver(
 566                                 rte_cryptodev_driver_id_get(
 567                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
 568                 if (nb_devs < 1) {
 569                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 570                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
 571                                 "Failed to create instance of"
 572                                 " pmd : %s",
 573                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
 574                 }
 575         }
 576
 577         /* Create a SNOW 3G device if required */
 578         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 579                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
 580                 nb_devs = rte_cryptodev_device_count_by_driver(
 581                                 rte_cryptodev_driver_id_get(
 582                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
 583                 if (nb_devs < 1) {
 584                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 585                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
 586                                 "Failed to create instance of"
 587                                 " pmd : %s",
 588                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
 589                 }
 590         }
 591
 592         /* Create a KASUMI device if required */
 593         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 594                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
 595                 nb_devs = rte_cryptodev_device_count_by_driver(
 596                                 rte_cryptodev_driver_id_get(
 597                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
 598                 if (nb_devs < 1) {
 599                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 600                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
 601                                 "Failed to create instance of"
 602                                 " pmd : %s",
 603                                 RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
 604                 }
 605         }
 606
 607         /* Create a ZUC device if required */
 608         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 609                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
 610                 nb_devs = rte_cryptodev_device_count_by_driver(
 611                                 rte_cryptodev_driver_id_get(
 612                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
 613                 if (nb_devs < 1) {
 614                         TEST_ASSERT_SUCCESS(rte_vdev_init(
 615                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
 616                                 "Failed to create instance of"
 617                                 " pmd : %s",
 618                                 RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
 619                 }
 620         }
 621
 622         /* Create a NULL device if required */
 623         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 624                         RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
 625                 nb_devs = rte_cryptodev_device_count_by_driver(
 626                                 rte_cryptodev_driver_id_get(
 627                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
 628                 if (nb_devs < 1) {
 629                         ret = rte_vdev_init(
 630                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
 631
 632                         TEST_ASSERT(ret == 0,
 633                                 "Failed to create instance of"
 634                                 " pmd : %s",
 635                                 RTE_STR(CRYPTODEV_NAME_NULL_PMD));
 636                 }
 637         }
 638
 639         /* Create an OPENSSL device if required */
 640         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 641                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
 642                 nb_devs = rte_cryptodev_device_count_by_driver(
 643                                 rte_cryptodev_driver_id_get(
 644                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
 645                 if (nb_devs < 1) {
 646                         ret = rte_vdev_init(
 647                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
 648                                 NULL);
 649
 650                         TEST_ASSERT(ret == 0, "Failed to create "
 651                                 "instance of pmd : %s",
 652                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
 653                 }
 654         }
 655
 656         /* Create a ARMv8 device if required */
 657         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 658                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
 659                 nb_devs = rte_cryptodev_device_count_by_driver(
 660                                 rte_cryptodev_driver_id_get(
 661                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
 662                 if (nb_devs < 1) {
 663                         ret = rte_vdev_init(
 664                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
 665                                 NULL);
 666
 667                         TEST_ASSERT(ret == 0, "Failed to create "
 668                                 "instance of pmd : %s",
 669                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
 670                 }
 671         }
 672
 673         /* Create a MVSAM device if required */
 674         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 675                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
 676                 nb_devs = rte_cryptodev_device_count_by_driver(
 677                                 rte_cryptodev_driver_id_get(
 678                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
 679                 if (nb_devs < 1) {
 680                         ret = rte_vdev_init(
 681                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
 682                                 NULL);
 683
 684                         TEST_ASSERT(ret == 0, "Failed to create "
 685                                 "instance of pmd : %s",
 686                                 RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
 687                 }
 688         }
 689
 690         /* Create an CCP device if required */
 691         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 692                         RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
 693                 nb_devs = rte_cryptodev_device_count_by_driver(
 694                                 rte_cryptodev_driver_id_get(
 695                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
 696                 if (nb_devs < 1) {
 697                         ret = rte_vdev_init(
 698                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD),
 699                                 NULL);
 700
 701                         TEST_ASSERT(ret == 0, "Failed to create "
 702                                 "instance of pmd : %s",
 703                                 RTE_STR(CRYPTODEV_NAME_CCP_PMD));
 704                 }
 705         }
 706
 707 #ifdef RTE_CRYPTO_SCHEDULER
 708         char vdev_args[VDEV_ARGS_SIZE] = {""};
 709         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
 710                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
 711         uint16_t worker_core_count = 0;
 712         uint16_t socket_id = 0;
 713
 714         if (gbl_driver_id == rte_cryptodev_driver_id_get(
 715                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
 716
 717                 /* Identify the Worker Cores
 718                  * Use 2 worker cores for the device args
 719                  */
 720                 RTE_LCORE_FOREACH_WORKER(i) {
 721                         if (worker_core_count > 1)
 722                                 break;
 723                         snprintf(vdev_args, sizeof(vdev_args),
 724                                         "%s%d", temp_str, i);
 725                         strcpy(temp_str, vdev_args);
 726                         strlcat(temp_str, ";", sizeof(temp_str));
 727                         worker_core_count++;
 728                         socket_id = rte_lcore_to_socket_id(i);
 729                 }
 730                 if (worker_core_count != 2) {
 731                         RTE_LOG(ERR, USER1,
 732                                 "Cryptodev scheduler test require at least "
 733                                 "two worker cores to run. "
 734                                 "Please use the correct coremask.\n");
 735                         return TEST_FAILED;
 736                 }
 737                 strcpy(temp_str, vdev_args);
 738                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
 739                                 temp_str, socket_id);
 740                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
 741                 nb_devs = rte_cryptodev_device_count_by_driver(
 742                                 rte_cryptodev_driver_id_get(
 743                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
 744                 if (nb_devs < 1) {
 745                         ret = rte_vdev_init(
 746                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
 747                                         vdev_args);
 748                         TEST_ASSERT(ret == 0,
 749                                 "Failed to create instance %u of"
 750                                 " pmd : %s",
 751                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 752                 }
 753         }
 754 #endif /* RTE_CRYPTO_SCHEDULER */
 755
 756         nb_devs = rte_cryptodev_count();
 757         if (nb_devs < 1) {
 758                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 759                 return TEST_SKIPPED;
 760         }
 761
 762         /* Create list of valid crypto devs */
 763         for (i = 0; i < nb_devs; i++) {
 764                 rte_cryptodev_info_get(i, &info);
 765                 if (info.driver_id == gbl_driver_id)
 766                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 767         }
 768
 769         if (ts_params->valid_dev_count < 1)
 770                 return TEST_FAILED;
 771
 772         /* Set up all the qps on the first of the valid devices found */
 773
 774         dev_id = ts_params->valid_devs[0];
 775
 776         rte_cryptodev_info_get(dev_id, &info);
 777
 778         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 779         ts_params->conf.socket_id = SOCKET_ID_ANY;
 780         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 781
 782         unsigned int session_size =
 783                 rte_cryptodev_sym_get_private_session_size(dev_id);
 784
 785 #ifdef RTE_LIB_SECURITY
 786         unsigned int security_session_size = rte_security_session_get_size(
 787                         rte_cryptodev_get_sec_ctx(dev_id));
 788
 789         if (session_size < security_session_size)
 790                 session_size = security_session_size;
 791 #endif
 792         /*
 793          * Create mempool with maximum number of sessions.
 794          */
 795         if (info.sym.max_nb_sessions != 0 &&
 796                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 797                 RTE_LOG(ERR, USER1, "Device does not support "
 798                                 "at least %u sessions\n",
 799                                 MAX_NB_SESSIONS);
 800                 return TEST_FAILED;
 801         }
 802
 803         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 804                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 805                         SOCKET_ID_ANY);
 806         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 807                         "session mempool allocation failed");
 808
 809         ts_params->session_priv_mpool = rte_mempool_create(
 810                         "test_sess_mp_priv",
 811                         MAX_NB_SESSIONS,
 812                         session_size,
 813                         0, 0, NULL, NULL, NULL,
 814                         NULL, SOCKET_ID_ANY,
 815                         0);
 816         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 817                         "session mempool allocation failed");
 818
 819
 820
 821         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 822                         &ts_params->conf),
 823                         "Failed to configure cryptodev %u with %u qps",
 824                         dev_id, ts_params->conf.nb_queue_pairs);
 825
 826         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 827         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 828         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 829
 830         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 831                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 832                         dev_id, qp_id, &ts_params->qp_conf,
 833                         rte_cryptodev_socket_id(dev_id)),
 834                         "Failed to setup queue pair %u on cryptodev %u",
 835                         qp_id, dev_id);
 836         }
 837
 838         return TEST_SUCCESS;
 839 }
 840
 841 static void
 842 testsuite_teardown(void)
 843 {
 844         struct crypto_testsuite_params *ts_params = &testsuite_params;
 845
 846         if (ts_params->mbuf_pool != NULL) {
 847                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 848                 rte_mempool_avail_count(ts_params->mbuf_pool));
 849         }
 850
 851         if (ts_params->op_mpool != NULL) {
 852                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 853                 rte_mempool_avail_count(ts_params->op_mpool));
 854         }
 855
 856         /* Free session mempools */
 857         if (ts_params->session_priv_mpool != NULL) {
 858                 rte_mempool_free(ts_params->session_priv_mpool);
 859                 ts_params->session_priv_mpool = NULL;
 860         }
 861
 862         if (ts_params->session_mpool != NULL) {
 863                 rte_mempool_free(ts_params->session_mpool);
 864                 ts_params->session_mpool = NULL;
 865         }
 866 }
 867
 868 static int
 869 dev_configure_and_start(uint64_t ff_disable)
 870 {
 871         struct crypto_testsuite_params *ts_params = &testsuite_params;
 872         struct crypto_unittest_params *ut_params = &unittest_params;
 873
 874         uint16_t qp_id;
 875
 876         /* Clear unit test parameters before running test */
 877         memset(ut_params, 0, sizeof(*ut_params));
 878
 879         /* Reconfigure device to default parameters */
 880         ts_params->conf.socket_id = SOCKET_ID_ANY;
 881         ts_params->conf.ff_disable = ff_disable;
 882         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 883         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 884         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 885
 886         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 887                         &ts_params->conf),
 888                         "Failed to configure cryptodev %u",
 889                         ts_params->valid_devs[0]);
 890
 891         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
 892                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 893                         ts_params->valid_devs[0], qp_id,
 894                         &ts_params->qp_conf,
 895                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
 896                         "Failed to setup queue pair %u on cryptodev %u",
 897                         qp_id, ts_params->valid_devs[0]);
 898         }
 899
 900
 901         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
 902
 903         /* Start the device */
 904         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
 905                         "Failed to start cryptodev %u",
 906                         ts_params->valid_devs[0]);
 907
 908         return TEST_SUCCESS;
 909 }
 910
 911 static int
 912 ut_setup(void)
 913 {
 914         /* Configure and start the device with security feature disabled */
 915         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
 916 }
 917
 918 static int
 919 ut_setup_security(void)
 920 {
 921         /* Configure and start the device with no features disabled */
 922         return dev_configure_and_start(0);
 923 }
 924
 925 static void
 926 ut_teardown(void)
 927 {
 928         struct crypto_testsuite_params *ts_params = &testsuite_params;
 929         struct crypto_unittest_params *ut_params = &unittest_params;
 930         struct rte_cryptodev_stats stats;
 931
 932         /* free crypto session structure */
 933 #ifdef RTE_LIB_SECURITY
 934         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
 935                 if (ut_params->sec_session) {
 936                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
 937                                                 (ts_params->valid_devs[0]),
 938                                                 ut_params->sec_session);
 939                         ut_params->sec_session = NULL;
 940                 }
 941         } else
 942 #endif
 943         {
 944                 if (ut_params->sess) {
 945                         rte_cryptodev_sym_session_clear(
 946                                         ts_params->valid_devs[0],
 947                                         ut_params->sess);
 948                         rte_cryptodev_sym_session_free(ut_params->sess);
 949                         ut_params->sess = NULL;
 950                 }
 951         }
 952
 953         /* free crypto operation structure */
 954         if (ut_params->op)
 955                 rte_crypto_op_free(ut_params->op);
 956
 957         /*
 958          * free mbuf - both obuf and ibuf are usually the same,
 959          * so check if they point at the same address is necessary,
 960          * to avoid freeing the mbuf twice.
 961          */
 962         if (ut_params->obuf) {
 963                 rte_pktmbuf_free(ut_params->obuf);
 964                 if (ut_params->ibuf == ut_params->obuf)
 965                         ut_params->ibuf = 0;
 966                 ut_params->obuf = 0;
 967         }
 968         if (ut_params->ibuf) {
 969                 rte_pktmbuf_free(ut_params->ibuf);
 970                 ut_params->ibuf = 0;
 971         }
 972
 973         if (ts_params->mbuf_pool != NULL)
 974                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 975                         rte_mempool_avail_count(ts_params->mbuf_pool));
 976
 977         rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats);
 978
 979         /* Stop the device */
 980         rte_cryptodev_stop(ts_params->valid_devs[0]);
 981 }
 982
 983 static int
 984 test_device_configure_invalid_dev_id(void)
 985 {
 986         struct crypto_testsuite_params *ts_params = &testsuite_params;
 987         uint16_t dev_id, num_devs = 0;
 988
 989         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
 990                         "Need at least %d devices for test", 1);
 991
 992         /* valid dev_id values */
 993         dev_id = ts_params->valid_devs[0];
 994
 995         /* Stop the device in case it's started so it can be configured */
 996         rte_cryptodev_stop(dev_id);
 997
 998         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
 999                         "Failed test for rte_cryptodev_configure: "
1000                         "invalid dev_num %u", dev_id);
1001
1002         /* invalid dev_id values */
1003         dev_id = num_devs;
1004
1005         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1006                         "Failed test for rte_cryptodev_configure: "
1007                         "invalid dev_num %u", dev_id);
1008
1009         dev_id = 0xff;
1010
1011         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1012                         "Failed test for rte_cryptodev_configure:"
1013                         "invalid dev_num %u", dev_id);
1014
1015         return TEST_SUCCESS;
1016 }
1017
1018 static int
1019 test_device_configure_invalid_queue_pair_ids(void)
1020 {
1021         struct crypto_testsuite_params *ts_params = &testsuite_params;
1022         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1023
1024         /* Stop the device in case it's started so it can be configured */
1025         rte_cryptodev_stop(ts_params->valid_devs[0]);
1026
1027         /* valid - max value queue pairs */
1028         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1029
1030         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1031                         &ts_params->conf),
1032                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1033                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1034
1035         /* valid - one queue pairs */
1036         ts_params->conf.nb_queue_pairs = 1;
1037
1038         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1039                         &ts_params->conf),
1040                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1041                         ts_params->valid_devs[0],
1042                         ts_params->conf.nb_queue_pairs);
1043
1044
1045         /* invalid - zero queue pairs */
1046         ts_params->conf.nb_queue_pairs = 0;
1047
1048         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1049                         &ts_params->conf),
1050                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1051                         " invalid qps: %u",
1052                         ts_params->valid_devs[0],
1053                         ts_params->conf.nb_queue_pairs);
1054
1055
1056         /* invalid - max value supported by field queue pairs */
1057         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1058
1059         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1060                         &ts_params->conf),
1061                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1062                         " invalid qps: %u",
1063                         ts_params->valid_devs[0],
1064                         ts_params->conf.nb_queue_pairs);
1065
1066
1067         /* invalid - max value + 1 queue pairs */
1068         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1069
1070         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1071                         &ts_params->conf),
1072                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1073                         " invalid qps: %u",
1074                         ts_params->valid_devs[0],
1075                         ts_params->conf.nb_queue_pairs);
1076
1077         /* revert to original testsuite value */
1078         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1079
1080         return TEST_SUCCESS;
1081 }
1082
1083 static int
1084 test_queue_pair_descriptor_setup(void)
1085 {
1086         struct crypto_testsuite_params *ts_params = &testsuite_params;
1087         struct rte_cryptodev_qp_conf qp_conf = {
1088                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1089         };
1090         uint16_t qp_id;
1091
1092         /* Stop the device in case it's started so it can be configured */
1093         rte_cryptodev_stop(ts_params->valid_devs[0]);
1094
1095         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1096                         &ts_params->conf),
1097                         "Failed to configure cryptodev %u",
1098                         ts_params->valid_devs[0]);
1099
1100         /*
1101          * Test various ring sizes on this device. memzones can't be
1102          * freed so are re-used if ring is released and re-created.
1103          */
1104         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1105         qp_conf.mp_session = ts_params->session_mpool;
1106         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1107
1108         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1109                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1110                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1111                                 rte_cryptodev_socket_id(
1112                                                 ts_params->valid_devs[0])),
1113                                 "Failed test for "
1114                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1115                                 "%u on qp %u on cryptodev %u",
1116                                 qp_conf.nb_descriptors, qp_id,
1117                                 ts_params->valid_devs[0]);
1118         }
1119
1120         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1121
1122         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1123                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1124                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1125                                 rte_cryptodev_socket_id(
1126                                                 ts_params->valid_devs[0])),
1127                                 "Failed test for"
1128                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1129                                 " %u on qp %u on cryptodev %u",
1130                                 qp_conf.nb_descriptors, qp_id,
1131                                 ts_params->valid_devs[0]);
1132         }
1133
1134         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1135
1136         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1137                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1138                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1139                                 rte_cryptodev_socket_id(
1140                                                 ts_params->valid_devs[0])),
1141                                 "Failed test for "
1142                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1143                                 " %u on qp %u on cryptodev %u",
1144                                 qp_conf.nb_descriptors, qp_id,
1145                                 ts_params->valid_devs[0]);
1146         }
1147
1148         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1149
1150         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1151                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1152                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1153                                 rte_cryptodev_socket_id(
1154                                                 ts_params->valid_devs[0])),
1155                                 "Failed test for"
1156                                 " rte_cryptodev_queue_pair_setup:"
1157                                 "num_inflights %u on qp %u on cryptodev %u",
1158                                 qp_conf.nb_descriptors, qp_id,
1159                                 ts_params->valid_devs[0]);
1160         }
1161
1162         /* test invalid queue pair id */
1163         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1164
1165         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1166
1167         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1168                         ts_params->valid_devs[0],
1169                         qp_id, &qp_conf,
1170                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1171                         "Failed test for rte_cryptodev_queue_pair_setup:"
1172                         "invalid qp %u on cryptodev %u",
1173                         qp_id, ts_params->valid_devs[0]);
1174
1175         qp_id = 0xffff; /*invalid*/
1176
1177         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1178                         ts_params->valid_devs[0],
1179                         qp_id, &qp_conf,
1180                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1181                         "Failed test for rte_cryptodev_queue_pair_setup:"
1182                         "invalid qp %u on cryptodev %u",
1183                         qp_id, ts_params->valid_devs[0]);
1184
1185         return TEST_SUCCESS;
1186 }
1187
1188 /* ***** Plaintext data for tests ***** */
1189
1190 const char catch_22_quote_1[] =
1191                 "There was only one catch and that was Catch-22, which "
1192                 "specified that a concern for one's safety in the face of "
1193                 "dangers that were real and immediate was the process of a "
1194                 "rational mind. Orr was crazy and could be grounded. All he "
1195                 "had to do was ask; and as soon as he did, he would no longer "
1196                 "be crazy and would have to fly more missions. Orr would be "
1197                 "crazy to fly more missions and sane if he didn't, but if he "
1198                 "was sane he had to fly them. If he flew them he was crazy "
1199                 "and didn't have to; but if he didn't want to he was sane and "
1200                 "had to. Yossarian was moved very deeply by the absolute "
1201                 "simplicity of this clause of Catch-22 and let out a "
1202                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1203                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1204
1205 const char catch_22_quote[] =
1206                 "What a lousy earth! He wondered how many people were "
1207                 "destitute that same night even in his own prosperous country, "
1208                 "how many homes were shanties, how many husbands were drunk "
1209                 "and wives socked, and how many children were bullied, abused, "
1210                 "or abandoned. How many families hungered for food they could "
1211                 "not afford to buy? How many hearts were broken? How many "
1212                 "suicides would take place that same night, how many people "
1213                 "would go insane? How many cockroaches and landlords would "
1214                 "triumph? How many winners were losers, successes failures, "
1215                 "and rich men poor men? How many wise guys were stupid? How "
1216                 "many happy endings were unhappy endings? How many honest men "
1217                 "were liars, brave men cowards, loyal men traitors, how many "
1218                 "sainted men were corrupt, how many people in positions of "
1219                 "trust had sold their souls to bodyguards, how many had never "
1220                 "had souls? How many straight-and-narrow paths were crooked "
1221                 "paths? How many best families were worst families and how "
1222                 "many good people were bad people? When you added them all up "
1223                 "and then subtracted, you might be left with only the children, "
1224                 "and perhaps with Albert Einstein and an old violinist or "
1225                 "sculptor somewhere.";
1226
1227 #define QUOTE_480_BYTES         (480)
1228 #define QUOTE_512_BYTES         (512)
1229 #define QUOTE_768_BYTES         (768)
1230 #define QUOTE_1024_BYTES        (1024)
1231
1232
1233
1234 /* ***** SHA1 Hash Tests ***** */
1235
1236 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1237
1238 static uint8_t hmac_sha1_key[] = {
1239         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1240         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1241         0xDE, 0xF4, 0xDE, 0xAD };
1242
1243 /* ***** SHA224 Hash Tests ***** */
1244
1245 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1246
1247
1248 /* ***** AES-CBC Cipher Tests ***** */
1249
1250 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1251 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1252
1253 static uint8_t aes_cbc_key[] = {
1254         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1255         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1256
1257 static uint8_t aes_cbc_iv[] = {
1258         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1259         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1260
1261
1262 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1263
1264 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1265         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1266         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1267         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1268         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1269         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1270         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1271         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1272         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1273         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1274         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1275         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1276         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1277         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1278         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1279         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1280         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1281         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1282         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1283         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1284         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1285         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1286         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1287         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1288         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1289         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1290         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1291         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1292         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1293         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1294         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1295         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1296         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1297         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1298         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1299         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1300         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1301         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1302         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1303         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1304         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1305         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1306         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1307         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1308         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1309         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1310         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1311         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1312         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1313         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1314         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1315         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1316         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1317         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1318         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1319         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1320         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1321         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1322         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1323         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1324         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1325         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1326         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1327         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1328         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1329 };
1330
1331 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1332         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1333         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1334         0x18, 0x8c, 0x1d, 0x32
1335 };
1336
1337
1338 /* Multisession Vector context Test */
1339 /*Begin Session 0 */
1340 static uint8_t ms_aes_cbc_key0[] = {
1341         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1342         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1343 };
1344
1345 static uint8_t ms_aes_cbc_iv0[] = {
1346         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1347         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1348 };
1349
1350 static const uint8_t ms_aes_cbc_cipher0[] = {
1351                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1352                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1353                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1354                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1355                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1356                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1357                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1358                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1359                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1360                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1361                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1362                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1363                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1364                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1365                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1366                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1367                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1368                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1369                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1370                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1371                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1372                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1373                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1374                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1375                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1376                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1377                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1378                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1379                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1380                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1381                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1382                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1383                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1384                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1385                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1386                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1387                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1388                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1389                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1390                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1391                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1392                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1393                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1394                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1395                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1396                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1397                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1398                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1399                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1400                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1401                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1402                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1403                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1404                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1405                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1406                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1407                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1408                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1409                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1410                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1411                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1412                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1413                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1414                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1415 };
1416
1417
1418 static  uint8_t ms_hmac_key0[] = {
1419                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1420                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1421                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1422                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1423                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1424                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1425                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1426                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1427 };
1428
1429 static const uint8_t ms_hmac_digest0[] = {
1430                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1431                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1432                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1433                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1434                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1435                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1436                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1437                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1438                 };
1439
1440 /* End Session 0 */
1441 /* Begin session 1 */
1442
1443 static  uint8_t ms_aes_cbc_key1[] = {
1444                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1445                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1446 };
1447
1448 static  uint8_t ms_aes_cbc_iv1[] = {
1449         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1450         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1451 };
1452
1453 static const uint8_t ms_aes_cbc_cipher1[] = {
1454                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1455                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1456                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1457                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1458                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1459                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1460                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1461                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1462                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1463                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1464                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1465                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1466                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1467                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1468                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1469                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1470                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1471                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1472                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1473                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1474                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1475                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1476                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1477                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1478                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1479                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1480                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1481                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1482                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1483                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1484                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1485                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1486                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1487                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1488                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1489                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1490                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1491                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1492                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1493                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1494                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1495                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1496                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1497                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1498                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1499                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1500                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1501                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1502                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1503                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1504                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1505                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1506                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1507                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1508                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1509                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1510                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
1511                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
1512                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
1513                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
1514                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
1515                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
1516                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
1517                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
1518
1519 };
1520
1521 static uint8_t ms_hmac_key1[] = {
1522                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1523                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1524                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1525                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1526                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1527                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1528                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1529                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1530 };
1531
1532 static const uint8_t ms_hmac_digest1[] = {
1533                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
1534                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
1535                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
1536                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
1537                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
1538                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
1539                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
1540                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
1541 };
1542 /* End Session 1  */
1543 /* Begin Session 2 */
1544 static  uint8_t ms_aes_cbc_key2[] = {
1545                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1546                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1547 };
1548
1549 static  uint8_t ms_aes_cbc_iv2[] = {
1550                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1551                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1552 };
1553
1554 static const uint8_t ms_aes_cbc_cipher2[] = {
1555                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
1556                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
1557                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
1558                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
1559                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
1560                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
1561                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
1562                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
1563                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
1564                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
1565                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
1566                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
1567                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
1568                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
1569                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
1570                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
1571                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
1572                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
1573                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
1574                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
1575                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
1576                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
1577                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
1578                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
1579                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
1580                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
1581                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
1582                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
1583                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
1584                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
1585                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
1586                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
1587                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
1588                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
1589                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
1590                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
1591                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
1592                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
1593                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
1594                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
1595                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
1596                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
1597                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
1598                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
1599                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
1600                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
1601                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
1602                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
1603                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
1604                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
1605                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
1606                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
1607                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
1608                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
1609                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
1610                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
1611                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
1612                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
1613                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
1614                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
1615                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
1616                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
1617                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
1618                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
1619 };
1620
1621 static  uint8_t ms_hmac_key2[] = {
1622                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1623                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1624                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1625                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1626                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1627                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1628                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1629                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1630 };
1631
1632 static const uint8_t ms_hmac_digest2[] = {
1633                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
1634                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
1635                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
1636                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
1637                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
1638                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
1639                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
1640                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
1641 };
1642
1643 /* End Session 2 */
1644
1645
1646 static int
1647 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
1648 {
1649         struct crypto_testsuite_params *ts_params = &testsuite_params;
1650         struct crypto_unittest_params *ut_params = &unittest_params;
1651
1652         /* Verify the capabilities */
1653         struct rte_cryptodev_sym_capability_idx cap_idx;
1654         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1655         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
1656         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1657                         &cap_idx) == NULL)
1658                 return -ENOTSUP;
1659         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1660         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
1661         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
1662                         &cap_idx) == NULL)
1663                 return -ENOTSUP;
1664
1665         /* Generate test mbuf data and space for digest */
1666         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1667                         catch_22_quote, QUOTE_512_BYTES, 0);
1668
1669         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1670                         DIGEST_BYTE_LENGTH_SHA1);
1671         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1672
1673         /* Setup Cipher Parameters */
1674         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1675         ut_params->cipher_xform.next = &ut_params->auth_xform;
1676
1677         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1678         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
1679         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
1680         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1681         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1682         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1683
1684         /* Setup HMAC Parameters */
1685         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1686
1687         ut_params->auth_xform.next = NULL;
1688
1689         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
1690         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
1691         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
1692         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
1693         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
1694
1695         ut_params->sess = rte_cryptodev_sym_session_create(
1696                         ts_params->session_mpool);
1697
1698         /* Create crypto session*/
1699         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
1700                         ut_params->sess, &ut_params->cipher_xform,
1701                         ts_params->session_priv_mpool);
1702         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1703
1704         /* Generate crypto op data structure */
1705         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1706                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1707         TEST_ASSERT_NOT_NULL(ut_params->op,
1708                         "Failed to allocate symmetric crypto operation struct");
1709
1710         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
1711
1712         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1713
1714         /* set crypto operation source mbuf */
1715         sym_op->m_src = ut_params->ibuf;
1716
1717         /* Set crypto operation authentication parameters */
1718         sym_op->auth.digest.data = ut_params->digest;
1719         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1720                         ut_params->ibuf, QUOTE_512_BYTES);
1721
1722         sym_op->auth.data.offset = 0;
1723         sym_op->auth.data.length = QUOTE_512_BYTES;
1724
1725         /* Copy IV at the end of the crypto operation */
1726         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1727                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
1728
1729         /* Set crypto operation cipher parameters */
1730         sym_op->cipher.data.offset = 0;
1731         sym_op->cipher.data.length = QUOTE_512_BYTES;
1732
1733         /* Process crypto operation */
1734         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1735                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1736                         ut_params->op);
1737         else
1738                 TEST_ASSERT_NOT_NULL(
1739                         process_crypto_request(ts_params->valid_devs[0],
1740                                 ut_params->op),
1741                                 "failed to process sym crypto op");
1742
1743         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1744                         "crypto op processing failed");
1745
1746         /* Validate obuf */
1747         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
1748                         uint8_t *);
1749
1750         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
1751                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
1752                         QUOTE_512_BYTES,
1753                         "ciphertext data not as expected");
1754
1755         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
1756
1757         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
1758                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
1759                         gbl_driver_id == rte_cryptodev_driver_id_get(
1760                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
1761                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
1762                                         DIGEST_BYTE_LENGTH_SHA1,
1763                         "Generated digest data not as expected");
1764
1765         return TEST_SUCCESS;
1766 }
1767
1768 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
1769
1770 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
1771
1772 static uint8_t hmac_sha512_key[] = {
1773         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1774         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1775         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1776         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
1777         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
1778         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1779         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
1780         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
1781
1782 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
1783         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
1784         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
1785         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
1786         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
1787         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
1788         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
1789         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
1790         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
1791
1792
1793
1794 static int
1795 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1796                 struct crypto_unittest_params *ut_params,
1797                 uint8_t *cipher_key,
1798                 uint8_t *hmac_key);
1799
1800 static int
1801 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1802                 struct crypto_unittest_params *ut_params,
1803                 struct crypto_testsuite_params *ts_params,
1804                 const uint8_t *cipher,
1805                 const uint8_t *digest,
1806                 const uint8_t *iv);
1807
1808
1809 static int
1810 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
1811                 struct crypto_unittest_params *ut_params,
1812                 uint8_t *cipher_key,
1813                 uint8_t *hmac_key)
1814 {
1815
1816         /* Setup Cipher Parameters */
1817         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1818         ut_params->cipher_xform.next = NULL;
1819
1820         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1821         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1822         ut_params->cipher_xform.cipher.key.data = cipher_key;
1823         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
1824         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1825         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1826
1827         /* Setup HMAC Parameters */
1828         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1829         ut_params->auth_xform.next = &ut_params->cipher_xform;
1830
1831         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1832         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
1833         ut_params->auth_xform.auth.key.data = hmac_key;
1834         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
1835         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
1836
1837         return TEST_SUCCESS;
1838 }
1839
1840
1841 static int
1842 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
1843                 struct crypto_unittest_params *ut_params,
1844                 struct crypto_testsuite_params *ts_params,
1845                 const uint8_t *cipher,
1846                 const uint8_t *digest,
1847                 const uint8_t *iv)
1848 {
1849         /* Generate test mbuf data and digest */
1850         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
1851                         (const char *)
1852                         cipher,
1853                         QUOTE_512_BYTES, 0);
1854
1855         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
1856                         DIGEST_BYTE_LENGTH_SHA512);
1857         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
1858
1859         rte_memcpy(ut_params->digest,
1860                         digest,
1861                         DIGEST_BYTE_LENGTH_SHA512);
1862
1863         /* Generate Crypto op data structure */
1864         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
1865                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1866         TEST_ASSERT_NOT_NULL(ut_params->op,
1867                         "Failed to allocate symmetric crypto operation struct");
1868
1869         rte_crypto_op_attach_sym_session(ut_params->op, sess);
1870
1871         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
1872
1873         /* set crypto operation source mbuf */
1874         sym_op->m_src = ut_params->ibuf;
1875
1876         sym_op->auth.digest.data = ut_params->digest;
1877         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
1878                         ut_params->ibuf, QUOTE_512_BYTES);
1879
1880         sym_op->auth.data.offset = 0;
1881         sym_op->auth.data.length = QUOTE_512_BYTES;
1882
1883         /* Copy IV at the end of the crypto operation */
1884         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
1885                         iv, CIPHER_IV_LENGTH_AES_CBC);
1886
1887         sym_op->cipher.data.offset = 0;
1888         sym_op->cipher.data.length = QUOTE_512_BYTES;
1889
1890         /* Process crypto operation */
1891         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
1892                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
1893                         ut_params->op);
1894         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1895                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
1896                                 ut_params->op, 1, 1, 0, 0);
1897         else
1898                 TEST_ASSERT_NOT_NULL(
1899                                 process_crypto_request(ts_params->valid_devs[0],
1900                                         ut_params->op),
1901                                         "failed to process sym crypto op");
1902
1903         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1904                         "crypto op processing failed");
1905
1906         ut_params->obuf = ut_params->op->sym->m_src;
1907
1908         /* Validate obuf */
1909         TEST_ASSERT_BUFFERS_ARE_EQUAL(
1910                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
1911                         catch_22_quote,
1912                         QUOTE_512_BYTES,
1913                         "Plaintext data not as expected");
1914
1915         /* Validate obuf */
1916         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
1917                         "Digest verification failed");
1918
1919         return TEST_SUCCESS;
1920 }
1921
1922 static int
1923 test_blockcipher(enum blockcipher_test_type test_type)
1924 {
1925         struct crypto_testsuite_params *ts_params = &testsuite_params;
1926         int status;
1927
1928         status = test_blockcipher_all_tests(ts_params->mbuf_pool,
1929                 ts_params->op_mpool,
1930                 ts_params->session_mpool, ts_params->session_priv_mpool,
1931                 ts_params->valid_devs[0],
1932                 test_type);
1933
1934         if (status == -ENOTSUP)
1935                 return status;
1936
1937         TEST_ASSERT_EQUAL(status, 0, "Test failed");
1938
1939         return TEST_SUCCESS;
1940 }
1941
1942 static int
1943 test_AES_cipheronly_all(void)
1944 {
1945         return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE);
1946 }
1947
1948 static int
1949 test_AES_docsis_all(void)
1950 {
1951         /* Data-path service does not support DOCSIS yet */
1952         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1953                 return -ENOTSUP;
1954         return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
1955 }
1956
1957 static int
1958 test_DES_docsis_all(void)
1959 {
1960         /* Data-path service does not support DOCSIS yet */
1961         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
1962                 return -ENOTSUP;
1963         return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
1964 }
1965
1966 static int
1967 test_DES_cipheronly_all(void)
1968 {
1969         return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE);
1970 }
1971
1972 static int
1973 test_authonly_all(void)
1974 {
1975         return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE);
1976 }
1977
1978 static int
1979 test_AES_chain_all(void)
1980 {
1981         return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE);
1982 }
1983
1984 static int
1985 test_3DES_chain_all(void)
1986 {
1987         return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE);
1988 }
1989
1990 static int
1991 test_3DES_cipheronly_all(void)
1992 {
1993         return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE);
1994 }
1995
1996 /* ***** SNOW 3G Tests ***** */
1997 static int
1998 create_wireless_algo_hash_session(uint8_t dev_id,
1999         const uint8_t *key, const uint8_t key_len,
2000         const uint8_t iv_len, const uint8_t auth_len,
2001         enum rte_crypto_auth_operation op,
2002         enum rte_crypto_auth_algorithm algo)
2003 {
2004         uint8_t hash_key[key_len];
2005         int status;
2006
2007         struct crypto_testsuite_params *ts_params = &testsuite_params;
2008         struct crypto_unittest_params *ut_params = &unittest_params;
2009
2010         memcpy(hash_key, key, key_len);
2011
2012         debug_hexdump(stdout, "key:", key, key_len);
2013
2014         /* Setup Authentication Parameters */
2015         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2016         ut_params->auth_xform.next = NULL;
2017
2018         ut_params->auth_xform.auth.op = op;
2019         ut_params->auth_xform.auth.algo = algo;
2020         ut_params->auth_xform.auth.key.length = key_len;
2021         ut_params->auth_xform.auth.key.data = hash_key;
2022         ut_params->auth_xform.auth.digest_length = auth_len;
2023         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2024         ut_params->auth_xform.auth.iv.length = iv_len;
2025         ut_params->sess = rte_cryptodev_sym_session_create(
2026                         ts_params->session_mpool);
2027
2028         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2029                         &ut_params->auth_xform,
2030                         ts_params->session_priv_mpool);
2031         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2032         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2033         return 0;
2034 }
2035
2036 static int
2037 create_wireless_algo_cipher_session(uint8_t dev_id,
2038                         enum rte_crypto_cipher_operation op,
2039                         enum rte_crypto_cipher_algorithm algo,
2040                         const uint8_t *key, const uint8_t key_len,
2041                         uint8_t iv_len)
2042 {
2043         uint8_t cipher_key[key_len];
2044         int status;
2045         struct crypto_testsuite_params *ts_params = &testsuite_params;
2046         struct crypto_unittest_params *ut_params = &unittest_params;
2047
2048         memcpy(cipher_key, key, key_len);
2049
2050         /* Setup Cipher Parameters */
2051         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2052         ut_params->cipher_xform.next = NULL;
2053
2054         ut_params->cipher_xform.cipher.algo = algo;
2055         ut_params->cipher_xform.cipher.op = op;
2056         ut_params->cipher_xform.cipher.key.data = cipher_key;
2057         ut_params->cipher_xform.cipher.key.length = key_len;
2058         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2059         ut_params->cipher_xform.cipher.iv.length = iv_len;
2060
2061         debug_hexdump(stdout, "key:", key, key_len);
2062
2063         /* Create Crypto session */
2064         ut_params->sess = rte_cryptodev_sym_session_create(
2065                         ts_params->session_mpool);
2066
2067         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2068                         &ut_params->cipher_xform,
2069                         ts_params->session_priv_mpool);
2070         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2071         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2072         return 0;
2073 }
2074
2075 static int
2076 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2077                         unsigned int cipher_len,
2078                         unsigned int cipher_offset)
2079 {
2080         struct crypto_testsuite_params *ts_params = &testsuite_params;
2081         struct crypto_unittest_params *ut_params = &unittest_params;
2082
2083         /* Generate Crypto op data structure */
2084         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2085                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2086         TEST_ASSERT_NOT_NULL(ut_params->op,
2087                                 "Failed to allocate pktmbuf offload");
2088
2089         /* Set crypto operation data parameters */
2090         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2091
2092         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2093
2094         /* set crypto operation source mbuf */
2095         sym_op->m_src = ut_params->ibuf;
2096
2097         /* iv */
2098         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2099                         iv, iv_len);
2100         sym_op->cipher.data.length = cipher_len;
2101         sym_op->cipher.data.offset = cipher_offset;
2102         return 0;
2103 }
2104
2105 static int
2106 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2107                         unsigned int cipher_len,
2108                         unsigned int cipher_offset)
2109 {
2110         struct crypto_testsuite_params *ts_params = &testsuite_params;
2111         struct crypto_unittest_params *ut_params = &unittest_params;
2112
2113         /* Generate Crypto op data structure */
2114         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2115                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2116         TEST_ASSERT_NOT_NULL(ut_params->op,
2117                                 "Failed to allocate pktmbuf offload");
2118
2119         /* Set crypto operation data parameters */
2120         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2121
2122         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2123
2124         /* set crypto operation source mbuf */
2125         sym_op->m_src = ut_params->ibuf;
2126         sym_op->m_dst = ut_params->obuf;
2127
2128         /* iv */
2129         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2130                         iv, iv_len);
2131         sym_op->cipher.data.length = cipher_len;
2132         sym_op->cipher.data.offset = cipher_offset;
2133         return 0;
2134 }
2135
2136 static int
2137 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2138                 enum rte_crypto_cipher_operation cipher_op,
2139                 enum rte_crypto_auth_operation auth_op,
2140                 enum rte_crypto_auth_algorithm auth_algo,
2141                 enum rte_crypto_cipher_algorithm cipher_algo,
2142                 const uint8_t *key, uint8_t key_len,
2143                 uint8_t auth_iv_len, uint8_t auth_len,
2144                 uint8_t cipher_iv_len)
2145
2146 {
2147         uint8_t cipher_auth_key[key_len];
2148         int status;
2149
2150         struct crypto_testsuite_params *ts_params = &testsuite_params;
2151         struct crypto_unittest_params *ut_params = &unittest_params;
2152
2153         memcpy(cipher_auth_key, key, key_len);
2154
2155         /* Setup Authentication Parameters */
2156         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2157         ut_params->auth_xform.next = NULL;
2158
2159         ut_params->auth_xform.auth.op = auth_op;
2160         ut_params->auth_xform.auth.algo = auth_algo;
2161         ut_params->auth_xform.auth.key.length = key_len;
2162         /* Hash key = cipher key */
2163         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2164         ut_params->auth_xform.auth.digest_length = auth_len;
2165         /* Auth IV will be after cipher IV */
2166         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2167         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2168
2169         /* Setup Cipher Parameters */
2170         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2171         ut_params->cipher_xform.next = &ut_params->auth_xform;
2172
2173         ut_params->cipher_xform.cipher.algo = cipher_algo;
2174         ut_params->cipher_xform.cipher.op = cipher_op;
2175         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2176         ut_params->cipher_xform.cipher.key.length = key_len;
2177         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2178         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2179
2180         debug_hexdump(stdout, "key:", key, key_len);
2181
2182         /* Create Crypto session*/
2183         ut_params->sess = rte_cryptodev_sym_session_create(
2184                         ts_params->session_mpool);
2185         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2186
2187         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2188                         &ut_params->cipher_xform,
2189                         ts_params->session_priv_mpool);
2190         if (status == -ENOTSUP)
2191                 return status;
2192
2193         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2194         return 0;
2195 }
2196
2197 static int
2198 create_wireless_cipher_auth_session(uint8_t dev_id,
2199                 enum rte_crypto_cipher_operation cipher_op,
2200                 enum rte_crypto_auth_operation auth_op,
2201                 enum rte_crypto_auth_algorithm auth_algo,
2202                 enum rte_crypto_cipher_algorithm cipher_algo,
2203                 const struct wireless_test_data *tdata)
2204 {
2205         const uint8_t key_len = tdata->key.len;
2206         uint8_t cipher_auth_key[key_len];
2207         int status;
2208
2209         struct crypto_testsuite_params *ts_params = &testsuite_params;
2210         struct crypto_unittest_params *ut_params = &unittest_params;
2211         const uint8_t *key = tdata->key.data;
2212         const uint8_t auth_len = tdata->digest.len;
2213         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2214         uint8_t auth_iv_len = tdata->auth_iv.len;
2215
2216         memcpy(cipher_auth_key, key, key_len);
2217
2218         /* Setup Authentication Parameters */
2219         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2220         ut_params->auth_xform.next = NULL;
2221
2222         ut_params->auth_xform.auth.op = auth_op;
2223         ut_params->auth_xform.auth.algo = auth_algo;
2224         ut_params->auth_xform.auth.key.length = key_len;
2225         /* Hash key = cipher key */
2226         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2227         ut_params->auth_xform.auth.digest_length = auth_len;
2228         /* Auth IV will be after cipher IV */
2229         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2230         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2231
2232         /* Setup Cipher Parameters */
2233         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2234         ut_params->cipher_xform.next = &ut_params->auth_xform;
2235
2236         ut_params->cipher_xform.cipher.algo = cipher_algo;
2237         ut_params->cipher_xform.cipher.op = cipher_op;
2238         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2239         ut_params->cipher_xform.cipher.key.length = key_len;
2240         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2241         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2242
2243
2244         debug_hexdump(stdout, "key:", key, key_len);
2245
2246         /* Create Crypto session*/
2247         ut_params->sess = rte_cryptodev_sym_session_create(
2248                         ts_params->session_mpool);
2249
2250         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2251                         &ut_params->cipher_xform,
2252                         ts_params->session_priv_mpool);
2253         if (status == -ENOTSUP)
2254                 return status;
2255
2256         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2257         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2258         return 0;
2259 }
2260
2261 static int
2262 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2263                 const struct wireless_test_data *tdata)
2264 {
2265         return create_wireless_cipher_auth_session(dev_id,
2266                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2267                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2268                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2269 }
2270
2271 static int
2272 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2273                 enum rte_crypto_cipher_operation cipher_op,
2274                 enum rte_crypto_auth_operation auth_op,
2275                 enum rte_crypto_auth_algorithm auth_algo,
2276                 enum rte_crypto_cipher_algorithm cipher_algo,
2277                 const uint8_t *key, const uint8_t key_len,
2278                 uint8_t auth_iv_len, uint8_t auth_len,
2279                 uint8_t cipher_iv_len)
2280 {
2281         uint8_t auth_cipher_key[key_len];
2282         int status;
2283         struct crypto_testsuite_params *ts_params = &testsuite_params;
2284         struct crypto_unittest_params *ut_params = &unittest_params;
2285
2286         memcpy(auth_cipher_key, key, key_len);
2287
2288         /* Setup Authentication Parameters */
2289         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2290         ut_params->auth_xform.auth.op = auth_op;
2291         ut_params->auth_xform.next = &ut_params->cipher_xform;
2292         ut_params->auth_xform.auth.algo = auth_algo;
2293         ut_params->auth_xform.auth.key.length = key_len;
2294         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2295         ut_params->auth_xform.auth.digest_length = auth_len;
2296         /* Auth IV will be after cipher IV */
2297         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2298         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2299
2300         /* Setup Cipher Parameters */
2301         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2302         ut_params->cipher_xform.next = NULL;
2303         ut_params->cipher_xform.cipher.algo = cipher_algo;
2304         ut_params->cipher_xform.cipher.op = cipher_op;
2305         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2306         ut_params->cipher_xform.cipher.key.length = key_len;
2307         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2308         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2309
2310         debug_hexdump(stdout, "key:", key, key_len);
2311
2312         /* Create Crypto session*/
2313         ut_params->sess = rte_cryptodev_sym_session_create(
2314                         ts_params->session_mpool);
2315         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2316
2317         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2318                 ut_params->auth_xform.next = NULL;
2319                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2320                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2321                                 &ut_params->cipher_xform,
2322                                 ts_params->session_priv_mpool);
2323
2324         } else
2325                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2326                                 &ut_params->auth_xform,
2327                                 ts_params->session_priv_mpool);
2328
2329         if (status == -ENOTSUP)
2330                 return status;
2331
2332         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2333
2334         return 0;
2335 }
2336
2337 static int
2338 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2339                 unsigned int auth_tag_len,
2340                 const uint8_t *iv, unsigned int iv_len,
2341                 unsigned int data_pad_len,
2342                 enum rte_crypto_auth_operation op,
2343                 unsigned int auth_len, unsigned int auth_offset)
2344 {
2345         struct crypto_testsuite_params *ts_params = &testsuite_params;
2346
2347         struct crypto_unittest_params *ut_params = &unittest_params;
2348
2349         /* Generate Crypto op data structure */
2350         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2351                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2352         TEST_ASSERT_NOT_NULL(ut_params->op,
2353                 "Failed to allocate pktmbuf offload");
2354
2355         /* Set crypto operation data parameters */
2356         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2357
2358         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2359
2360         /* set crypto operation source mbuf */
2361         sym_op->m_src = ut_params->ibuf;
2362
2363         /* iv */
2364         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2365                         iv, iv_len);
2366         /* digest */
2367         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2368                                         ut_params->ibuf, auth_tag_len);
2369
2370         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2371                                 "no room to append auth tag");
2372         ut_params->digest = sym_op->auth.digest.data;
2373         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2374                         ut_params->ibuf, data_pad_len);
2375         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2376                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2377         else
2378                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2379
2380         debug_hexdump(stdout, "digest:",
2381                 sym_op->auth.digest.data,
2382                 auth_tag_len);
2383
2384         sym_op->auth.data.length = auth_len;
2385         sym_op->auth.data.offset = auth_offset;
2386
2387         return 0;
2388 }
2389
2390 static int
2391 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2392         enum rte_crypto_auth_operation op)
2393 {
2394         struct crypto_testsuite_params *ts_params = &testsuite_params;
2395         struct crypto_unittest_params *ut_params = &unittest_params;
2396
2397         const uint8_t *auth_tag = tdata->digest.data;
2398         const unsigned int auth_tag_len = tdata->digest.len;
2399         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2400         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2401
2402         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2403         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2404         const uint8_t *auth_iv = tdata->auth_iv.data;
2405         const uint8_t auth_iv_len = tdata->auth_iv.len;
2406         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2407         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2408
2409         /* Generate Crypto op data structure */
2410         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2411                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2412         TEST_ASSERT_NOT_NULL(ut_params->op,
2413                         "Failed to allocate pktmbuf offload");
2414         /* Set crypto operation data parameters */
2415         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2416
2417         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2418
2419         /* set crypto operation source mbuf */
2420         sym_op->m_src = ut_params->ibuf;
2421
2422         /* digest */
2423         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2424                         ut_params->ibuf, auth_tag_len);
2425
2426         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2427                         "no room to append auth tag");
2428         ut_params->digest = sym_op->auth.digest.data;
2429         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2430                         ut_params->ibuf, data_pad_len);
2431         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2432                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2433         else
2434                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2435
2436         debug_hexdump(stdout, "digest:",
2437                 sym_op->auth.digest.data,
2438                 auth_tag_len);
2439
2440         /* Copy cipher and auth IVs at the end of the crypto operation */
2441         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2442                                                 IV_OFFSET);
2443         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2444         iv_ptr += cipher_iv_len;
2445         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2446
2447         sym_op->cipher.data.length = cipher_len;
2448         sym_op->cipher.data.offset = 0;
2449         sym_op->auth.data.length = auth_len;
2450         sym_op->auth.data.offset = 0;
2451
2452         return 0;
2453 }
2454
2455 static int
2456 create_zuc_cipher_hash_generate_operation(
2457                 const struct wireless_test_data *tdata)
2458 {
2459         return create_wireless_cipher_hash_operation(tdata,
2460                 RTE_CRYPTO_AUTH_OP_GENERATE);
2461 }
2462
2463 static int
2464 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2465                 const unsigned auth_tag_len,
2466                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2467                 unsigned data_pad_len,
2468                 enum rte_crypto_auth_operation op,
2469                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2470                 const unsigned cipher_len, const unsigned cipher_offset,
2471                 const unsigned auth_len, const unsigned auth_offset)
2472 {
2473         struct crypto_testsuite_params *ts_params = &testsuite_params;
2474         struct crypto_unittest_params *ut_params = &unittest_params;
2475
2476         enum rte_crypto_cipher_algorithm cipher_algo =
2477                         ut_params->cipher_xform.cipher.algo;
2478         enum rte_crypto_auth_algorithm auth_algo =
2479                         ut_params->auth_xform.auth.algo;
2480
2481         /* Generate Crypto op data structure */
2482         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2483                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2484         TEST_ASSERT_NOT_NULL(ut_params->op,
2485                         "Failed to allocate pktmbuf offload");
2486         /* Set crypto operation data parameters */
2487         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2488
2489         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2490
2491         /* set crypto operation source mbuf */
2492         sym_op->m_src = ut_params->ibuf;
2493
2494         /* digest */
2495         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2496                         ut_params->ibuf, auth_tag_len);
2497
2498         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2499                         "no room to append auth tag");
2500         ut_params->digest = sym_op->auth.digest.data;
2501
2502         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2503                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2504                                 ut_params->ibuf, data_pad_len);
2505         } else {
2506                 struct rte_mbuf *m = ut_params->ibuf;
2507                 unsigned int offset = data_pad_len;
2508
2509                 while (offset > m->data_len && m->next != NULL) {
2510                         offset -= m->data_len;
2511                         m = m->next;
2512                 }
2513                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2514                         m, offset);
2515         }
2516
2517         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2518                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2519         else
2520                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2521
2522         debug_hexdump(stdout, "digest:",
2523                 sym_op->auth.digest.data,
2524                 auth_tag_len);
2525
2526         /* Copy cipher and auth IVs at the end of the crypto operation */
2527         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2528                                                 IV_OFFSET);
2529         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2530         iv_ptr += cipher_iv_len;
2531         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2532
2533         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2534                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2535                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2536                 sym_op->cipher.data.length = cipher_len;
2537                 sym_op->cipher.data.offset = cipher_offset;
2538         } else {
2539                 sym_op->cipher.data.length = cipher_len >> 3;
2540                 sym_op->cipher.data.offset = cipher_offset >> 3;
2541         }
2542
2543         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2544                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2545                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2546                 sym_op->auth.data.length = auth_len;
2547                 sym_op->auth.data.offset = auth_offset;
2548         } else {
2549                 sym_op->auth.data.length = auth_len >> 3;
2550                 sym_op->auth.data.offset = auth_offset >> 3;
2551         }
2552
2553         return 0;
2554 }
2555
2556 static int
2557 create_wireless_algo_auth_cipher_operation(
2558                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2559                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2560                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2561                 unsigned int data_pad_len,
2562                 unsigned int cipher_len, unsigned int cipher_offset,
2563                 unsigned int auth_len, unsigned int auth_offset,
2564                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2565 {
2566         struct crypto_testsuite_params *ts_params = &testsuite_params;
2567         struct crypto_unittest_params *ut_params = &unittest_params;
2568
2569         enum rte_crypto_cipher_algorithm cipher_algo =
2570                         ut_params->cipher_xform.cipher.algo;
2571         enum rte_crypto_auth_algorithm auth_algo =
2572                         ut_params->auth_xform.auth.algo;
2573
2574         /* Generate Crypto op data structure */
2575         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2576                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2577         TEST_ASSERT_NOT_NULL(ut_params->op,
2578                         "Failed to allocate pktmbuf offload");
2579
2580         /* Set crypto operation data parameters */
2581         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2582
2583         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2584
2585         /* set crypto operation mbufs */
2586         sym_op->m_src = ut_params->ibuf;
2587         if (op_mode == OUT_OF_PLACE)
2588                 sym_op->m_dst = ut_params->obuf;
2589
2590         /* digest */
2591         if (!do_sgl) {
2592                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
2593                         (op_mode == IN_PLACE ?
2594                                 ut_params->ibuf : ut_params->obuf),
2595                         uint8_t *, data_pad_len);
2596                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2597                         (op_mode == IN_PLACE ?
2598                                 ut_params->ibuf : ut_params->obuf),
2599                         data_pad_len);
2600                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2601         } else {
2602                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
2603                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
2604                                 sym_op->m_src : sym_op->m_dst);
2605                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
2606                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
2607                         sgl_buf = sgl_buf->next;
2608                 }
2609                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
2610                                 uint8_t *, remaining_off);
2611                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
2612                                 remaining_off);
2613                 memset(sym_op->auth.digest.data, 0, remaining_off);
2614                 while (sgl_buf->next != NULL) {
2615                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
2616                                 0, rte_pktmbuf_data_len(sgl_buf));
2617                         sgl_buf = sgl_buf->next;
2618                 }
2619         }
2620
2621         /* Copy digest for the verification */
2622         if (verify)
2623                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2624
2625         /* Copy cipher and auth IVs at the end of the crypto operation */
2626         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
2627                         ut_params->op, uint8_t *, IV_OFFSET);
2628
2629         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2630         iv_ptr += cipher_iv_len;
2631         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2632
2633         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2634                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2635                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2636                 sym_op->cipher.data.length = cipher_len;
2637                 sym_op->cipher.data.offset = cipher_offset;
2638         } else {
2639                 sym_op->cipher.data.length = cipher_len >> 3;
2640                 sym_op->cipher.data.offset = cipher_offset >> 3;
2641         }
2642
2643         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2644                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2645                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2646                 sym_op->auth.data.length = auth_len;
2647                 sym_op->auth.data.offset = auth_offset;
2648         } else {
2649                 sym_op->auth.data.length = auth_len >> 3;
2650                 sym_op->auth.data.offset = auth_offset >> 3;
2651         }
2652
2653         return 0;
2654 }
2655
2656 static int
2657 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
2658 {
2659         struct crypto_testsuite_params *ts_params = &testsuite_params;
2660         struct crypto_unittest_params *ut_params = &unittest_params;
2661
2662         int retval;
2663         unsigned plaintext_pad_len;
2664         unsigned plaintext_len;
2665         uint8_t *plaintext;
2666         struct rte_cryptodev_info dev_info;
2667
2668         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2669         uint64_t feat_flags = dev_info.feature_flags;
2670
2671         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2672                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2673                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2674                 return -ENOTSUP;
2675         }
2676
2677         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2678                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2679                 printf("Device doesn't support RAW data-path APIs.\n");
2680                 return -ENOTSUP;
2681         }
2682
2683         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2684                 return -ENOTSUP;
2685
2686         /* Verify the capabilities */
2687         struct rte_cryptodev_sym_capability_idx cap_idx;
2688         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2689         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2690         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2691                         &cap_idx) == NULL)
2692                 return -ENOTSUP;
2693
2694         /* Create SNOW 3G session */
2695         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2696                         tdata->key.data, tdata->key.len,
2697                         tdata->auth_iv.len, tdata->digest.len,
2698                         RTE_CRYPTO_AUTH_OP_GENERATE,
2699                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2700         if (retval < 0)
2701                 return retval;
2702
2703         /* alloc mbuf and set payload */
2704         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2705
2706         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2707         rte_pktmbuf_tailroom(ut_params->ibuf));
2708
2709         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2710         /* Append data which is padded to a multiple of */
2711         /* the algorithms block size */
2712         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2713         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2714                                 plaintext_pad_len);
2715         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2716
2717         /* Create SNOW 3G operation */
2718         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2719                         tdata->auth_iv.data, tdata->auth_iv.len,
2720                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2721                         tdata->validAuthLenInBits.len,
2722                         0);
2723         if (retval < 0)
2724                 return retval;
2725
2726         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2727                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2728                                 ut_params->op, 0, 1, 1, 0);
2729         else
2730                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2731                                 ut_params->op);
2732         ut_params->obuf = ut_params->op->sym->m_src;
2733         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2734         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2735                         + plaintext_pad_len;
2736
2737         /* Validate obuf */
2738         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2739         ut_params->digest,
2740         tdata->digest.data,
2741         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
2742         "SNOW 3G Generated auth tag not as expected");
2743
2744         return 0;
2745 }
2746
2747 static int
2748 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
2749 {
2750         struct crypto_testsuite_params *ts_params = &testsuite_params;
2751         struct crypto_unittest_params *ut_params = &unittest_params;
2752
2753         int retval;
2754         unsigned plaintext_pad_len;
2755         unsigned plaintext_len;
2756         uint8_t *plaintext;
2757         struct rte_cryptodev_info dev_info;
2758
2759         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2760         uint64_t feat_flags = dev_info.feature_flags;
2761
2762         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
2763                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
2764                 printf("Device doesn't support NON-Byte Aligned Data.\n");
2765                 return -ENOTSUP;
2766         }
2767
2768         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2769                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2770                 printf("Device doesn't support RAW data-path APIs.\n");
2771                 return -ENOTSUP;
2772         }
2773
2774         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2775                 return -ENOTSUP;
2776
2777         /* Verify the capabilities */
2778         struct rte_cryptodev_sym_capability_idx cap_idx;
2779         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2780         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
2781         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2782                         &cap_idx) == NULL)
2783                 return -ENOTSUP;
2784
2785         /* Create SNOW 3G session */
2786         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2787                                 tdata->key.data, tdata->key.len,
2788                                 tdata->auth_iv.len, tdata->digest.len,
2789                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2790                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
2791         if (retval < 0)
2792                 return retval;
2793         /* alloc mbuf and set payload */
2794         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2795
2796         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2797         rte_pktmbuf_tailroom(ut_params->ibuf));
2798
2799         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2800         /* Append data which is padded to a multiple of */
2801         /* the algorithms block size */
2802         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2803         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2804                                 plaintext_pad_len);
2805         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2806
2807         /* Create SNOW 3G operation */
2808         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2809                         tdata->digest.len,
2810                         tdata->auth_iv.data, tdata->auth_iv.len,
2811                         plaintext_pad_len,
2812                         RTE_CRYPTO_AUTH_OP_VERIFY,
2813                         tdata->validAuthLenInBits.len,
2814                         0);
2815         if (retval < 0)
2816                 return retval;
2817
2818         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2819                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2820                                 ut_params->op, 0, 1, 1, 0);
2821         else
2822                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2823                                 ut_params->op);
2824         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2825         ut_params->obuf = ut_params->op->sym->m_src;
2826         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2827                                 + plaintext_pad_len;
2828
2829         /* Validate obuf */
2830         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
2831                 return 0;
2832         else
2833                 return -1;
2834
2835         return 0;
2836 }
2837
2838 static int
2839 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
2840 {
2841         struct crypto_testsuite_params *ts_params = &testsuite_params;
2842         struct crypto_unittest_params *ut_params = &unittest_params;
2843
2844         int retval;
2845         unsigned plaintext_pad_len;
2846         unsigned plaintext_len;
2847         uint8_t *plaintext;
2848         struct rte_cryptodev_info dev_info;
2849
2850         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2851         uint64_t feat_flags = dev_info.feature_flags;
2852
2853         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2854                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2855                 printf("Device doesn't support RAW data-path APIs.\n");
2856                 return -ENOTSUP;
2857         }
2858
2859         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2860                 return -ENOTSUP;
2861
2862         /* Verify the capabilities */
2863         struct rte_cryptodev_sym_capability_idx cap_idx;
2864         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2865         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2866         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2867                         &cap_idx) == NULL)
2868                 return -ENOTSUP;
2869
2870         /* Create KASUMI session */
2871         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2872                         tdata->key.data, tdata->key.len,
2873                         0, tdata->digest.len,
2874                         RTE_CRYPTO_AUTH_OP_GENERATE,
2875                         RTE_CRYPTO_AUTH_KASUMI_F9);
2876         if (retval < 0)
2877                 return retval;
2878
2879         /* alloc mbuf and set payload */
2880         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2881
2882         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2883         rte_pktmbuf_tailroom(ut_params->ibuf));
2884
2885         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2886         /* Append data which is padded to a multiple of */
2887         /* the algorithms block size */
2888         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2889         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2890                                 plaintext_pad_len);
2891         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2892
2893         /* Create KASUMI operation */
2894         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
2895                         NULL, 0,
2896                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
2897                         tdata->plaintext.len,
2898                         0);
2899         if (retval < 0)
2900                 return retval;
2901
2902         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2903                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2904                         ut_params->op);
2905         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2906                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2907                                 ut_params->op, 0, 1, 1, 0);
2908         else
2909                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2910                         ut_params->op);
2911
2912         ut_params->obuf = ut_params->op->sym->m_src;
2913         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2914         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
2915                         + plaintext_pad_len;
2916
2917         /* Validate obuf */
2918         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2919         ut_params->digest,
2920         tdata->digest.data,
2921         DIGEST_BYTE_LENGTH_KASUMI_F9,
2922         "KASUMI Generated auth tag not as expected");
2923
2924         return 0;
2925 }
2926
2927 static int
2928 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
2929 {
2930         struct crypto_testsuite_params *ts_params = &testsuite_params;
2931         struct crypto_unittest_params *ut_params = &unittest_params;
2932
2933         int retval;
2934         unsigned plaintext_pad_len;
2935         unsigned plaintext_len;
2936         uint8_t *plaintext;
2937         struct rte_cryptodev_info dev_info;
2938
2939         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
2940         uint64_t feat_flags = dev_info.feature_flags;
2941
2942         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
2943                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
2944                 printf("Device doesn't support RAW data-path APIs.\n");
2945                 return -ENOTSUP;
2946         }
2947
2948         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2949                 return -ENOTSUP;
2950
2951         /* Verify the capabilities */
2952         struct rte_cryptodev_sym_capability_idx cap_idx;
2953         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2954         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
2955         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2956                         &cap_idx) == NULL)
2957                 return -ENOTSUP;
2958
2959         /* Create KASUMI session */
2960         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
2961                                 tdata->key.data, tdata->key.len,
2962                                 0, tdata->digest.len,
2963                                 RTE_CRYPTO_AUTH_OP_VERIFY,
2964                                 RTE_CRYPTO_AUTH_KASUMI_F9);
2965         if (retval < 0)
2966                 return retval;
2967         /* alloc mbuf and set payload */
2968         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
2969
2970         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
2971         rte_pktmbuf_tailroom(ut_params->ibuf));
2972
2973         plaintext_len = ceil_byte_length(tdata->plaintext.len);
2974         /* Append data which is padded to a multiple */
2975         /* of the algorithms block size */
2976         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
2977         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2978                                 plaintext_pad_len);
2979         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
2980
2981         /* Create KASUMI operation */
2982         retval = create_wireless_algo_hash_operation(tdata->digest.data,
2983                         tdata->digest.len,
2984                         NULL, 0,
2985                         plaintext_pad_len,
2986                         RTE_CRYPTO_AUTH_OP_VERIFY,
2987                         tdata->plaintext.len,
2988                         0);
2989         if (retval < 0)
2990                 return retval;
2991
2992         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2993                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2994                                 ut_params->op, 0, 1, 1, 0);
2995         else
2996                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
2997                                 ut_params->op);
2998         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
2999         ut_params->obuf = ut_params->op->sym->m_src;
3000         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3001                                 + plaintext_pad_len;
3002
3003         /* Validate obuf */
3004         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3005                 return 0;
3006         else
3007                 return -1;
3008
3009         return 0;
3010 }
3011
3012 static int
3013 test_snow3g_hash_generate_test_case_1(void)
3014 {
3015         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3016 }
3017
3018 static int
3019 test_snow3g_hash_generate_test_case_2(void)
3020 {
3021         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3022 }
3023
3024 static int
3025 test_snow3g_hash_generate_test_case_3(void)
3026 {
3027         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3028 }
3029
3030 static int
3031 test_snow3g_hash_generate_test_case_4(void)
3032 {
3033         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3034 }
3035
3036 static int
3037 test_snow3g_hash_generate_test_case_5(void)
3038 {
3039         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3040 }
3041
3042 static int
3043 test_snow3g_hash_generate_test_case_6(void)
3044 {
3045         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3046 }
3047
3048 static int
3049 test_snow3g_hash_verify_test_case_1(void)
3050 {
3051         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3052
3053 }
3054
3055 static int
3056 test_snow3g_hash_verify_test_case_2(void)
3057 {
3058         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3059 }
3060
3061 static int
3062 test_snow3g_hash_verify_test_case_3(void)
3063 {
3064         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3065 }
3066
3067 static int
3068 test_snow3g_hash_verify_test_case_4(void)
3069 {
3070         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3071 }
3072
3073 static int
3074 test_snow3g_hash_verify_test_case_5(void)
3075 {
3076         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3077 }
3078
3079 static int
3080 test_snow3g_hash_verify_test_case_6(void)
3081 {
3082         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3083 }
3084
3085 static int
3086 test_kasumi_hash_generate_test_case_1(void)
3087 {
3088         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3089 }
3090
3091 static int
3092 test_kasumi_hash_generate_test_case_2(void)
3093 {
3094         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3095 }
3096
3097 static int
3098 test_kasumi_hash_generate_test_case_3(void)
3099 {
3100         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3101 }
3102
3103 static int
3104 test_kasumi_hash_generate_test_case_4(void)
3105 {
3106         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3107 }
3108
3109 static int
3110 test_kasumi_hash_generate_test_case_5(void)
3111 {
3112         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3113 }
3114
3115 static int
3116 test_kasumi_hash_generate_test_case_6(void)
3117 {
3118         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3119 }
3120
3121 static int
3122 test_kasumi_hash_verify_test_case_1(void)
3123 {
3124         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3125 }
3126
3127 static int
3128 test_kasumi_hash_verify_test_case_2(void)
3129 {
3130         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3131 }
3132
3133 static int
3134 test_kasumi_hash_verify_test_case_3(void)
3135 {
3136         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3137 }
3138
3139 static int
3140 test_kasumi_hash_verify_test_case_4(void)
3141 {
3142         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3143 }
3144
3145 static int
3146 test_kasumi_hash_verify_test_case_5(void)
3147 {
3148         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3149 }
3150
3151 static int
3152 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3153 {
3154         struct crypto_testsuite_params *ts_params = &testsuite_params;
3155         struct crypto_unittest_params *ut_params = &unittest_params;
3156
3157         int retval;
3158         uint8_t *plaintext, *ciphertext;
3159         unsigned plaintext_pad_len;
3160         unsigned plaintext_len;
3161         struct rte_cryptodev_info dev_info;
3162
3163         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3164         uint64_t feat_flags = dev_info.feature_flags;
3165
3166         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3167                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3168                 printf("Device doesn't support RAW data-path APIs.\n");
3169                 return -ENOTSUP;
3170         }
3171
3172         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3173                 return -ENOTSUP;
3174
3175         /* Verify the capabilities */
3176         struct rte_cryptodev_sym_capability_idx cap_idx;
3177         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3178         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3179         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3180                         &cap_idx) == NULL)
3181                 return -ENOTSUP;
3182
3183         /* Create KASUMI session */
3184         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3185                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3186                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3187                                         tdata->key.data, tdata->key.len,
3188                                         tdata->cipher_iv.len);
3189         if (retval < 0)
3190                 return retval;
3191
3192         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3193
3194         /* Clear mbuf payload */
3195         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3196                rte_pktmbuf_tailroom(ut_params->ibuf));
3197
3198         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3199         /* Append data which is padded to a multiple */
3200         /* of the algorithms block size */
3201         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3202         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3203                                 plaintext_pad_len);
3204         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3205
3206         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3207
3208         /* Create KASUMI operation */
3209         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3210                                 tdata->cipher_iv.len,
3211                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3212                                 tdata->validCipherOffsetInBits.len);
3213         if (retval < 0)
3214                 return retval;
3215
3216         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3217                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3218                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3219         else
3220                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3221                                 ut_params->op);
3222         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3223
3224         ut_params->obuf = ut_params->op->sym->m_dst;
3225         if (ut_params->obuf)
3226                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3227         else
3228                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3229
3230         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3231
3232         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3233                                 (tdata->validCipherOffsetInBits.len >> 3);
3234         /* Validate obuf */
3235         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3236                 ciphertext,
3237                 reference_ciphertext,
3238                 tdata->validCipherLenInBits.len,
3239                 "KASUMI Ciphertext data not as expected");
3240         return 0;
3241 }
3242
3243 static int
3244 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3245 {
3246         struct crypto_testsuite_params *ts_params = &testsuite_params;
3247         struct crypto_unittest_params *ut_params = &unittest_params;
3248
3249         int retval;
3250
3251         unsigned int plaintext_pad_len;
3252         unsigned int plaintext_len;
3253
3254         uint8_t buffer[10000];
3255         const uint8_t *ciphertext;
3256
3257         struct rte_cryptodev_info dev_info;
3258
3259         /* Verify the capabilities */
3260         struct rte_cryptodev_sym_capability_idx cap_idx;
3261         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3262         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3263         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3264                         &cap_idx) == NULL)
3265                 return -ENOTSUP;
3266
3267         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3268
3269         uint64_t feat_flags = dev_info.feature_flags;
3270
3271         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3272                 printf("Device doesn't support in-place scatter-gather. "
3273                                 "Test Skipped.\n");
3274                 return -ENOTSUP;
3275         }
3276
3277         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3278                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3279                 printf("Device doesn't support RAW data-path APIs.\n");
3280                 return -ENOTSUP;
3281         }
3282
3283         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3284                 return -ENOTSUP;
3285
3286         /* Create KASUMI session */
3287         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3288                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3289                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3290                                         tdata->key.data, tdata->key.len,
3291                                         tdata->cipher_iv.len);
3292         if (retval < 0)
3293                 return retval;
3294
3295         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3296
3297
3298         /* Append data which is padded to a multiple */
3299         /* of the algorithms block size */
3300         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3301
3302         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3303                         plaintext_pad_len, 10, 0);
3304
3305         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3306
3307         /* Create KASUMI operation */
3308         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3309                                 tdata->cipher_iv.len,
3310                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3311                                 tdata->validCipherOffsetInBits.len);
3312         if (retval < 0)
3313                 return retval;
3314
3315         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3316                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3317                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3318         else
3319                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3320                                                 ut_params->op);
3321         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3322
3323         ut_params->obuf = ut_params->op->sym->m_dst;
3324
3325         if (ut_params->obuf)
3326                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3327                                 plaintext_len, buffer);
3328         else
3329                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3330                                 tdata->validCipherOffsetInBits.len >> 3,
3331                                 plaintext_len, buffer);
3332
3333         /* Validate obuf */
3334         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3335
3336         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3337                                 (tdata->validCipherOffsetInBits.len >> 3);
3338         /* Validate obuf */
3339         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3340                 ciphertext,
3341                 reference_ciphertext,
3342                 tdata->validCipherLenInBits.len,
3343                 "KASUMI Ciphertext data not as expected");
3344         return 0;
3345 }
3346
3347 static int
3348 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3349 {
3350         struct crypto_testsuite_params *ts_params = &testsuite_params;
3351         struct crypto_unittest_params *ut_params = &unittest_params;
3352
3353         int retval;
3354         uint8_t *plaintext, *ciphertext;
3355         unsigned plaintext_pad_len;
3356         unsigned plaintext_len;
3357
3358         /* Verify the capabilities */
3359         struct rte_cryptodev_sym_capability_idx cap_idx;
3360         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3361         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3362         /* Data-path service does not support OOP */
3363         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3364                         &cap_idx) == NULL)
3365                 return -ENOTSUP;
3366
3367         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3368                 return -ENOTSUP;
3369
3370         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3371                 return -ENOTSUP;
3372
3373         /* Create KASUMI session */
3374         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3375                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3376                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3377                                         tdata->key.data, tdata->key.len,
3378                                         tdata->cipher_iv.len);
3379         if (retval < 0)
3380                 return retval;
3381
3382         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3383         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3384
3385         /* Clear mbuf payload */
3386         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3387                rte_pktmbuf_tailroom(ut_params->ibuf));
3388
3389         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3390         /* Append data which is padded to a multiple */
3391         /* of the algorithms block size */
3392         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3393         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3394                                 plaintext_pad_len);
3395         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3396         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3397
3398         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3399
3400         /* Create KASUMI operation */
3401         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3402                                 tdata->cipher_iv.len,
3403                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3404                                 tdata->validCipherOffsetInBits.len);
3405         if (retval < 0)
3406                 return retval;
3407
3408         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3409                                                 ut_params->op);
3410         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3411
3412         ut_params->obuf = ut_params->op->sym->m_dst;
3413         if (ut_params->obuf)
3414                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3415         else
3416                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3417
3418         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3419
3420         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3421                                 (tdata->validCipherOffsetInBits.len >> 3);
3422         /* Validate obuf */
3423         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3424                 ciphertext,
3425                 reference_ciphertext,
3426                 tdata->validCipherLenInBits.len,
3427                 "KASUMI Ciphertext data not as expected");
3428         return 0;
3429 }
3430
3431 static int
3432 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3433 {
3434         struct crypto_testsuite_params *ts_params = &testsuite_params;
3435         struct crypto_unittest_params *ut_params = &unittest_params;
3436
3437         int retval;
3438         unsigned int plaintext_pad_len;
3439         unsigned int plaintext_len;
3440
3441         const uint8_t *ciphertext;
3442         uint8_t buffer[2048];
3443
3444         struct rte_cryptodev_info dev_info;
3445
3446         /* Verify the capabilities */
3447         struct rte_cryptodev_sym_capability_idx cap_idx;
3448         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3449         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3450         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3451                         &cap_idx) == NULL)
3452                 return -ENOTSUP;
3453
3454         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3455                 return -ENOTSUP;
3456
3457         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3458                 return -ENOTSUP;
3459
3460         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3461
3462         uint64_t feat_flags = dev_info.feature_flags;
3463         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3464                 printf("Device doesn't support out-of-place scatter-gather "
3465                                 "in both input and output mbufs. "
3466                                 "Test Skipped.\n");
3467                 return -ENOTSUP;
3468         }
3469
3470         /* Create KASUMI session */
3471         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3472                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3473                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3474                                         tdata->key.data, tdata->key.len,
3475                                         tdata->cipher_iv.len);
3476         if (retval < 0)
3477                 return retval;
3478
3479         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3480         /* Append data which is padded to a multiple */
3481         /* of the algorithms block size */
3482         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3483
3484         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3485                         plaintext_pad_len, 10, 0);
3486         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3487                         plaintext_pad_len, 3, 0);
3488
3489         /* Append data which is padded to a multiple */
3490         /* of the algorithms block size */
3491         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3492
3493         /* Create KASUMI operation */
3494         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3495                                 tdata->cipher_iv.len,
3496                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3497                                 tdata->validCipherOffsetInBits.len);
3498         if (retval < 0)
3499                 return retval;
3500
3501         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3502                                                 ut_params->op);
3503         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3504
3505         ut_params->obuf = ut_params->op->sym->m_dst;
3506         if (ut_params->obuf)
3507                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3508                                 plaintext_pad_len, buffer);
3509         else
3510                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3511                                 tdata->validCipherOffsetInBits.len >> 3,
3512                                 plaintext_pad_len, buffer);
3513
3514         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3515                                 (tdata->validCipherOffsetInBits.len >> 3);
3516         /* Validate obuf */
3517         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3518                 ciphertext,
3519                 reference_ciphertext,
3520                 tdata->validCipherLenInBits.len,
3521                 "KASUMI Ciphertext data not as expected");
3522         return 0;
3523 }
3524
3525
3526 static int
3527 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3528 {
3529         struct crypto_testsuite_params *ts_params = &testsuite_params;
3530         struct crypto_unittest_params *ut_params = &unittest_params;
3531
3532         int retval;
3533         uint8_t *ciphertext, *plaintext;
3534         unsigned ciphertext_pad_len;
3535         unsigned ciphertext_len;
3536
3537         /* Verify the capabilities */
3538         struct rte_cryptodev_sym_capability_idx cap_idx;
3539         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3540         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3541         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3542                         &cap_idx) == NULL)
3543                 return -ENOTSUP;
3544
3545         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3546                 return -ENOTSUP;
3547
3548         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3549                 return -ENOTSUP;
3550
3551         /* Create KASUMI session */
3552         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3553                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3554                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3555                                         tdata->key.data, tdata->key.len,
3556                                         tdata->cipher_iv.len);
3557         if (retval < 0)
3558                 return retval;
3559
3560         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3561         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3562
3563         /* Clear mbuf payload */
3564         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3565                rte_pktmbuf_tailroom(ut_params->ibuf));
3566
3567         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3568         /* Append data which is padded to a multiple */
3569         /* of the algorithms block size */
3570         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3571         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3572                                 ciphertext_pad_len);
3573         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
3574         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3575
3576         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3577
3578         /* Create KASUMI operation */
3579         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3580                                 tdata->cipher_iv.len,
3581                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3582                                 tdata->validCipherOffsetInBits.len);
3583         if (retval < 0)
3584                 return retval;
3585
3586         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3587                                                 ut_params->op);
3588         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3589
3590         ut_params->obuf = ut_params->op->sym->m_dst;
3591         if (ut_params->obuf)
3592                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3593         else
3594                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3595
3596         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3597
3598         const uint8_t *reference_plaintext = tdata->plaintext.data +
3599                                 (tdata->validCipherOffsetInBits.len >> 3);
3600         /* Validate obuf */
3601         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3602                 plaintext,
3603                 reference_plaintext,
3604                 tdata->validCipherLenInBits.len,
3605                 "KASUMI Plaintext data not as expected");
3606         return 0;
3607 }
3608
3609 static int
3610 test_kasumi_decryption(const struct kasumi_test_data *tdata)
3611 {
3612         struct crypto_testsuite_params *ts_params = &testsuite_params;
3613         struct crypto_unittest_params *ut_params = &unittest_params;
3614
3615         int retval;
3616         uint8_t *ciphertext, *plaintext;
3617         unsigned ciphertext_pad_len;
3618         unsigned ciphertext_len;
3619         struct rte_cryptodev_info dev_info;
3620
3621         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3622         uint64_t feat_flags = dev_info.feature_flags;
3623
3624         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3625                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3626                 printf("Device doesn't support RAW data-path APIs.\n");
3627                 return -ENOTSUP;
3628         }
3629
3630         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3631                 return -ENOTSUP;
3632
3633         /* Verify the capabilities */
3634         struct rte_cryptodev_sym_capability_idx cap_idx;
3635         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3636         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3637         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3638                         &cap_idx) == NULL)
3639                 return -ENOTSUP;
3640
3641         /* Create KASUMI session */
3642         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3643                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3644                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3645                                         tdata->key.data, tdata->key.len,
3646                                         tdata->cipher_iv.len);
3647         if (retval < 0)
3648                 return retval;
3649
3650         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3651
3652         /* Clear mbuf payload */
3653         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3654                rte_pktmbuf_tailroom(ut_params->ibuf));
3655
3656         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
3657         /* Append data which is padded to a multiple */
3658         /* of the algorithms block size */
3659         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
3660         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3661                                 ciphertext_pad_len);
3662         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
3663
3664         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
3665
3666         /* Create KASUMI operation */
3667         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3668                                         tdata->cipher_iv.len,
3669                                         tdata->ciphertext.len,
3670                                         tdata->validCipherOffsetInBits.len);
3671         if (retval < 0)
3672                 return retval;
3673
3674         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3675                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3676                                 ut_params->op, 1, 0, 1, 0);
3677         else
3678                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3679                                                 ut_params->op);
3680         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3681
3682         ut_params->obuf = ut_params->op->sym->m_dst;
3683         if (ut_params->obuf)
3684                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3685         else
3686                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
3687
3688         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
3689
3690         const uint8_t *reference_plaintext = tdata->plaintext.data +
3691                                 (tdata->validCipherOffsetInBits.len >> 3);
3692         /* Validate obuf */
3693         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3694                 plaintext,
3695                 reference_plaintext,
3696                 tdata->validCipherLenInBits.len,
3697                 "KASUMI Plaintext data not as expected");
3698         return 0;
3699 }
3700
3701 static int
3702 test_snow3g_encryption(const struct snow3g_test_data *tdata)
3703 {
3704         struct crypto_testsuite_params *ts_params = &testsuite_params;
3705         struct crypto_unittest_params *ut_params = &unittest_params;
3706
3707         int retval;
3708         uint8_t *plaintext, *ciphertext;
3709         unsigned plaintext_pad_len;
3710         unsigned plaintext_len;
3711         struct rte_cryptodev_info dev_info;
3712
3713         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3714         uint64_t feat_flags = dev_info.feature_flags;
3715
3716         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3717                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3718                 printf("Device doesn't support RAW data-path APIs.\n");
3719                 return -ENOTSUP;
3720         }
3721
3722         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3723                 return -ENOTSUP;
3724
3725         /* Verify the capabilities */
3726         struct rte_cryptodev_sym_capability_idx cap_idx;
3727         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3728         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3729         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3730                         &cap_idx) == NULL)
3731                 return -ENOTSUP;
3732
3733         /* Create SNOW 3G session */
3734         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3735                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3736                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3737                                         tdata->key.data, tdata->key.len,
3738                                         tdata->cipher_iv.len);
3739         if (retval < 0)
3740                 return retval;
3741
3742         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3743
3744         /* Clear mbuf payload */
3745         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3746                rte_pktmbuf_tailroom(ut_params->ibuf));
3747
3748         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3749         /* Append data which is padded to a multiple of */
3750         /* the algorithms block size */
3751         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3752         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3753                                 plaintext_pad_len);
3754         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3755
3756         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3757
3758         /* Create SNOW 3G operation */
3759         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760                                         tdata->cipher_iv.len,
3761                                         tdata->validCipherLenInBits.len,
3762                                         0);
3763         if (retval < 0)
3764                 return retval;
3765
3766         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3767                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3768                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3769         else
3770                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3771                                                 ut_params->op);
3772         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3773
3774         ut_params->obuf = ut_params->op->sym->m_dst;
3775         if (ut_params->obuf)
3776                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3777         else
3778                 ciphertext = plaintext;
3779
3780         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3781
3782         /* Validate obuf */
3783         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3784                 ciphertext,
3785                 tdata->ciphertext.data,
3786                 tdata->validDataLenInBits.len,
3787                 "SNOW 3G Ciphertext data not as expected");
3788         return 0;
3789 }
3790
3791
3792 static int
3793 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
3794 {
3795         struct crypto_testsuite_params *ts_params = &testsuite_params;
3796         struct crypto_unittest_params *ut_params = &unittest_params;
3797         uint8_t *plaintext, *ciphertext;
3798
3799         int retval;
3800         unsigned plaintext_pad_len;
3801         unsigned plaintext_len;
3802
3803         /* Verify the capabilities */
3804         struct rte_cryptodev_sym_capability_idx cap_idx;
3805         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3806         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3807         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3808                         &cap_idx) == NULL)
3809                 return -ENOTSUP;
3810
3811         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3812                 return -ENOTSUP;
3813
3814         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3815                 return -ENOTSUP;
3816
3817         /* Create SNOW 3G session */
3818         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3819                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3820                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3821                                         tdata->key.data, tdata->key.len,
3822                                         tdata->cipher_iv.len);
3823         if (retval < 0)
3824                 return retval;
3825
3826         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3827         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3828
3829         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3830                         "Failed to allocate input buffer in mempool");
3831         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3832                         "Failed to allocate output buffer in mempool");
3833
3834         /* Clear mbuf payload */
3835         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3836                rte_pktmbuf_tailroom(ut_params->ibuf));
3837
3838         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3839         /* Append data which is padded to a multiple of */
3840         /* the algorithms block size */
3841         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3842         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3843                                 plaintext_pad_len);
3844         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3845         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3846
3847         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3848
3849         /* Create SNOW 3G operation */
3850         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3851                                         tdata->cipher_iv.len,
3852                                         tdata->validCipherLenInBits.len,
3853                                         0);
3854         if (retval < 0)
3855                 return retval;
3856
3857         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3858                                                 ut_params->op);
3859         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3860
3861         ut_params->obuf = ut_params->op->sym->m_dst;
3862         if (ut_params->obuf)
3863                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3864         else
3865                 ciphertext = plaintext;
3866
3867         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3868
3869         /* Validate obuf */
3870         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3871                 ciphertext,
3872                 tdata->ciphertext.data,
3873                 tdata->validDataLenInBits.len,
3874                 "SNOW 3G Ciphertext data not as expected");
3875         return 0;
3876 }
3877
3878 static int
3879 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
3880 {
3881         struct crypto_testsuite_params *ts_params = &testsuite_params;
3882         struct crypto_unittest_params *ut_params = &unittest_params;
3883
3884         int retval;
3885         unsigned int plaintext_pad_len;
3886         unsigned int plaintext_len;
3887         uint8_t buffer[10000];
3888         const uint8_t *ciphertext;
3889
3890         struct rte_cryptodev_info dev_info;
3891
3892         /* Verify the capabilities */
3893         struct rte_cryptodev_sym_capability_idx cap_idx;
3894         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3895         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
3896         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3897                         &cap_idx) == NULL)
3898                 return -ENOTSUP;
3899
3900         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3901                 return -ENOTSUP;
3902
3903         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3904                 return -ENOTSUP;
3905
3906         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3907
3908         uint64_t feat_flags = dev_info.feature_flags;
3909
3910         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3911                 printf("Device doesn't support out-of-place scatter-gather "
3912                                 "in both input and output mbufs. "
3913                                 "Test Skipped.\n");
3914                 return -ENOTSUP;
3915         }
3916
3917         /* Create SNOW 3G session */
3918         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3919                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3920                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3921                                         tdata->key.data, tdata->key.len,
3922                                         tdata->cipher_iv.len);
3923         if (retval < 0)
3924                 return retval;
3925
3926         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3927         /* Append data which is padded to a multiple of */
3928         /* the algorithms block size */
3929         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3930
3931         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3932                         plaintext_pad_len, 10, 0);
3933         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3934                         plaintext_pad_len, 3, 0);
3935
3936         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
3937                         "Failed to allocate input buffer in mempool");
3938         TEST_ASSERT_NOT_NULL(ut_params->obuf,
3939                         "Failed to allocate output buffer in mempool");
3940
3941         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3942
3943         /* Create SNOW 3G operation */
3944         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3945                                         tdata->cipher_iv.len,
3946                                         tdata->validCipherLenInBits.len,
3947                                         0);
3948         if (retval < 0)
3949                 return retval;
3950
3951         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3952                                                 ut_params->op);
3953         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3954
3955         ut_params->obuf = ut_params->op->sym->m_dst;
3956         if (ut_params->obuf)
3957                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3958                                 plaintext_len, buffer);
3959         else
3960                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
3961                                 plaintext_len, buffer);
3962
3963         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3964
3965         /* Validate obuf */
3966         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3967                 ciphertext,
3968                 tdata->ciphertext.data,
3969                 tdata->validDataLenInBits.len,
3970                 "SNOW 3G Ciphertext data not as expected");
3971
3972         return 0;
3973 }
3974
3975 /* Shift right a buffer by "offset" bits, "offset" < 8 */
3976 static void
3977 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
3978 {
3979         uint8_t curr_byte, prev_byte;
3980         uint32_t length_in_bytes = ceil_byte_length(length + offset);
3981         uint8_t lower_byte_mask = (1 << offset) - 1;
3982         unsigned i;
3983
3984         prev_byte = buffer[0];
3985         buffer[0] >>= offset;
3986
3987         for (i = 1; i < length_in_bytes; i++) {
3988                 curr_byte = buffer[i];
3989                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
3990                                 (curr_byte >> offset);
3991                 prev_byte = curr_byte;
3992         }
3993 }
3994
3995 static int
3996 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
3997 {
3998         struct crypto_testsuite_params *ts_params = &testsuite_params;
3999         struct crypto_unittest_params *ut_params = &unittest_params;
4000         uint8_t *plaintext, *ciphertext;
4001         int retval;
4002         uint32_t plaintext_len;
4003         uint32_t plaintext_pad_len;
4004         uint8_t extra_offset = 4;
4005         uint8_t *expected_ciphertext_shifted;
4006         struct rte_cryptodev_info dev_info;
4007
4008         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4009         uint64_t feat_flags = dev_info.feature_flags;
4010
4011         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4012                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4013                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4014                 return -ENOTSUP;
4015         }
4016
4017         /* Verify the capabilities */
4018         struct rte_cryptodev_sym_capability_idx cap_idx;
4019         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4020         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4021         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4022                         &cap_idx) == NULL)
4023                 return -ENOTSUP;
4024
4025         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4026                 return -ENOTSUP;
4027
4028         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4029                 return -ENOTSUP;
4030
4031         /* Create SNOW 3G session */
4032         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4033                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4034                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4035                                         tdata->key.data, tdata->key.len,
4036                                         tdata->cipher_iv.len);
4037         if (retval < 0)
4038                 return retval;
4039
4040         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4041         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4042
4043         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4044                         "Failed to allocate input buffer in mempool");
4045         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4046                         "Failed to allocate output buffer in mempool");
4047
4048         /* Clear mbuf payload */
4049         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4050                rte_pktmbuf_tailroom(ut_params->ibuf));
4051
4052         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4053         /*
4054          * Append data which is padded to a
4055          * multiple of the algorithms block size
4056          */
4057         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4058
4059         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4060                                                 plaintext_pad_len);
4061
4062         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4063
4064         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4065         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4066
4067 #ifdef RTE_APP_TEST_DEBUG
4068         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4069 #endif
4070         /* Create SNOW 3G operation */
4071         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4072                                         tdata->cipher_iv.len,
4073                                         tdata->validCipherLenInBits.len,
4074                                         extra_offset);
4075         if (retval < 0)
4076                 return retval;
4077
4078         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4079                                                 ut_params->op);
4080         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4081
4082         ut_params->obuf = ut_params->op->sym->m_dst;
4083         if (ut_params->obuf)
4084                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4085         else
4086                 ciphertext = plaintext;
4087
4088 #ifdef RTE_APP_TEST_DEBUG
4089         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4090 #endif
4091
4092         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4093
4094         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4095                         "failed to reserve memory for ciphertext shifted\n");
4096
4097         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4098                         ceil_byte_length(tdata->ciphertext.len));
4099         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4100                         extra_offset);
4101         /* Validate obuf */
4102         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4103                 ciphertext,
4104                 expected_ciphertext_shifted,
4105                 tdata->validDataLenInBits.len,
4106                 extra_offset,
4107                 "SNOW 3G Ciphertext data not as expected");
4108         return 0;
4109 }
4110
4111 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4112 {
4113         struct crypto_testsuite_params *ts_params = &testsuite_params;
4114         struct crypto_unittest_params *ut_params = &unittest_params;
4115
4116         int retval;
4117
4118         uint8_t *plaintext, *ciphertext;
4119         unsigned ciphertext_pad_len;
4120         unsigned ciphertext_len;
4121         struct rte_cryptodev_info dev_info;
4122
4123         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4124         uint64_t feat_flags = dev_info.feature_flags;
4125
4126         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4127                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4128                 printf("Device doesn't support RAW data-path APIs.\n");
4129                 return -ENOTSUP;
4130         }
4131
4132         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4133                 return -ENOTSUP;
4134
4135         /* Verify the capabilities */
4136         struct rte_cryptodev_sym_capability_idx cap_idx;
4137         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4138         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4139         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4140                         &cap_idx) == NULL)
4141                 return -ENOTSUP;
4142
4143         /* Create SNOW 3G session */
4144         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4145                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4146                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4147                                         tdata->key.data, tdata->key.len,
4148                                         tdata->cipher_iv.len);
4149         if (retval < 0)
4150                 return retval;
4151
4152         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4153
4154         /* Clear mbuf payload */
4155         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4156                rte_pktmbuf_tailroom(ut_params->ibuf));
4157
4158         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4159         /* Append data which is padded to a multiple of */
4160         /* the algorithms block size */
4161         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4162         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4163                                 ciphertext_pad_len);
4164         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4165
4166         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4167
4168         /* Create SNOW 3G operation */
4169         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4170                                         tdata->cipher_iv.len,
4171                                         tdata->validCipherLenInBits.len,
4172                                         tdata->cipher.offset_bits);
4173         if (retval < 0)
4174                 return retval;
4175
4176         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4177                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4178                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4179         else
4180                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4181                                                 ut_params->op);
4182         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4183         ut_params->obuf = ut_params->op->sym->m_dst;
4184         if (ut_params->obuf)
4185                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4186         else
4187                 plaintext = ciphertext;
4188
4189         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4190
4191         /* Validate obuf */
4192         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4193                                 tdata->plaintext.data,
4194                                 tdata->validDataLenInBits.len,
4195                                 "SNOW 3G Plaintext data not as expected");
4196         return 0;
4197 }
4198
4199 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4200 {
4201         struct crypto_testsuite_params *ts_params = &testsuite_params;
4202         struct crypto_unittest_params *ut_params = &unittest_params;
4203
4204         int retval;
4205
4206         uint8_t *plaintext, *ciphertext;
4207         unsigned ciphertext_pad_len;
4208         unsigned ciphertext_len;
4209
4210         /* Verify the capabilities */
4211         struct rte_cryptodev_sym_capability_idx cap_idx;
4212         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4213         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4214         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4215                         &cap_idx) == NULL)
4216                 return -ENOTSUP;
4217
4218         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4219                 return -ENOTSUP;
4220
4221         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4222                 return -ENOTSUP;
4223
4224         /* Create SNOW 3G session */
4225         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4226                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4227                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4228                                         tdata->key.data, tdata->key.len,
4229                                         tdata->cipher_iv.len);
4230         if (retval < 0)
4231                 return retval;
4232
4233         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4234         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4235
4236         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4237                         "Failed to allocate input buffer");
4238         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4239                         "Failed to allocate output buffer");
4240
4241         /* Clear mbuf payload */
4242         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4243                rte_pktmbuf_tailroom(ut_params->ibuf));
4244
4245         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4246                        rte_pktmbuf_tailroom(ut_params->obuf));
4247
4248         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4249         /* Append data which is padded to a multiple of */
4250         /* the algorithms block size */
4251         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4252         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4253                                 ciphertext_pad_len);
4254         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4255         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4256
4257         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4258
4259         /* Create SNOW 3G operation */
4260         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4261                                         tdata->cipher_iv.len,
4262                                         tdata->validCipherLenInBits.len,
4263                                         0);
4264         if (retval < 0)
4265                 return retval;
4266
4267         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4268                                                 ut_params->op);
4269         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4270         ut_params->obuf = ut_params->op->sym->m_dst;
4271         if (ut_params->obuf)
4272                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4273         else
4274                 plaintext = ciphertext;
4275
4276         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4277
4278         /* Validate obuf */
4279         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4280                                 tdata->plaintext.data,
4281                                 tdata->validDataLenInBits.len,
4282                                 "SNOW 3G Plaintext data not as expected");
4283         return 0;
4284 }
4285
4286 static int
4287 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4288 {
4289         struct crypto_testsuite_params *ts_params = &testsuite_params;
4290         struct crypto_unittest_params *ut_params = &unittest_params;
4291
4292         int retval;
4293
4294         uint8_t *plaintext, *ciphertext;
4295         unsigned int plaintext_pad_len;
4296         unsigned int plaintext_len;
4297
4298         struct rte_cryptodev_info dev_info;
4299         struct rte_cryptodev_sym_capability_idx cap_idx;
4300
4301         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4302         uint64_t feat_flags = dev_info.feature_flags;
4303
4304         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4305                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4306                         (tdata->validDataLenInBits.len % 8 != 0))) {
4307                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4308                 return -ENOTSUP;
4309         }
4310
4311         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4312                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4313                 printf("Device doesn't support RAW data-path APIs.\n");
4314                 return -ENOTSUP;
4315         }
4316
4317         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4318                 return -ENOTSUP;
4319
4320         /* Check if device supports ZUC EEA3 */
4321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4322         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4323
4324         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4325                         &cap_idx) == NULL)
4326                 return -ENOTSUP;
4327
4328         /* Check if device supports ZUC EIA3 */
4329         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4330         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4331
4332         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4333                         &cap_idx) == NULL)
4334                 return -ENOTSUP;
4335
4336         /* Create ZUC session */
4337         retval = create_zuc_cipher_auth_encrypt_generate_session(
4338                         ts_params->valid_devs[0],
4339                         tdata);
4340         if (retval < 0)
4341                 return retval;
4342         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4343
4344         /* clear mbuf payload */
4345         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4346                         rte_pktmbuf_tailroom(ut_params->ibuf));
4347
4348         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4349         /* Append data which is padded to a multiple of */
4350         /* the algorithms block size */
4351         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4352         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4353                                 plaintext_pad_len);
4354         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4355
4356         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4357
4358         /* Create ZUC operation */
4359         retval = create_zuc_cipher_hash_generate_operation(tdata);
4360         if (retval < 0)
4361                 return retval;
4362
4363         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4364                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4365                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4366         else
4367                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4368                         ut_params->op);
4369         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4370         ut_params->obuf = ut_params->op->sym->m_src;
4371         if (ut_params->obuf)
4372                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4373         else
4374                 ciphertext = plaintext;
4375
4376         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4377         /* Validate obuf */
4378         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4379                         ciphertext,
4380                         tdata->ciphertext.data,
4381                         tdata->validDataLenInBits.len,
4382                         "ZUC Ciphertext data not as expected");
4383
4384         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4385             + plaintext_pad_len;
4386
4387         /* Validate obuf */
4388         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4389                         ut_params->digest,
4390                         tdata->digest.data,
4391                         4,
4392                         "ZUC Generated auth tag not as expected");
4393         return 0;
4394 }
4395
4396 static int
4397 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4398 {
4399         struct crypto_testsuite_params *ts_params = &testsuite_params;
4400         struct crypto_unittest_params *ut_params = &unittest_params;
4401
4402         int retval;
4403
4404         uint8_t *plaintext, *ciphertext;
4405         unsigned plaintext_pad_len;
4406         unsigned plaintext_len;
4407         struct rte_cryptodev_info dev_info;
4408
4409         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4410         uint64_t feat_flags = dev_info.feature_flags;
4411
4412         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4413                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4414                 printf("Device doesn't support RAW data-path APIs.\n");
4415                 return -ENOTSUP;
4416         }
4417
4418         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4419                 return -ENOTSUP;
4420
4421         /* Verify the capabilities */
4422         struct rte_cryptodev_sym_capability_idx cap_idx;
4423         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4424         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4425         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4426                         &cap_idx) == NULL)
4427                 return -ENOTSUP;
4428         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4429         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4430         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4431                         &cap_idx) == NULL)
4432                 return -ENOTSUP;
4433
4434         /* Create SNOW 3G session */
4435         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4436                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4437                         RTE_CRYPTO_AUTH_OP_GENERATE,
4438                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4439                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4440                         tdata->key.data, tdata->key.len,
4441                         tdata->auth_iv.len, tdata->digest.len,
4442                         tdata->cipher_iv.len);
4443         if (retval < 0)
4444                 return retval;
4445         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4446
4447         /* clear mbuf payload */
4448         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4449                         rte_pktmbuf_tailroom(ut_params->ibuf));
4450
4451         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4452         /* Append data which is padded to a multiple of */
4453         /* the algorithms block size */
4454         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4455         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4456                                 plaintext_pad_len);
4457         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4458
4459         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4460
4461         /* Create SNOW 3G operation */
4462         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4463                         tdata->digest.len, tdata->auth_iv.data,
4464                         tdata->auth_iv.len,
4465                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4466                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4467                         tdata->validCipherLenInBits.len,
4468                         0,
4469                         tdata->validAuthLenInBits.len,
4470                         0
4471                         );
4472         if (retval < 0)
4473                 return retval;
4474
4475         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4476                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4477                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4478         else
4479                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4480                         ut_params->op);
4481         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4482         ut_params->obuf = ut_params->op->sym->m_src;
4483         if (ut_params->obuf)
4484                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4485         else
4486                 ciphertext = plaintext;
4487
4488         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4489         /* Validate obuf */
4490         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4491                         ciphertext,
4492                         tdata->ciphertext.data,
4493                         tdata->validDataLenInBits.len,
4494                         "SNOW 3G Ciphertext data not as expected");
4495
4496         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4497             + plaintext_pad_len;
4498
4499         /* Validate obuf */
4500         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4501                         ut_params->digest,
4502                         tdata->digest.data,
4503                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4504                         "SNOW 3G Generated auth tag not as expected");
4505         return 0;
4506 }
4507
4508 static int
4509 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4510         uint8_t op_mode, uint8_t verify)
4511 {
4512         struct crypto_testsuite_params *ts_params = &testsuite_params;
4513         struct crypto_unittest_params *ut_params = &unittest_params;
4514
4515         int retval;
4516
4517         uint8_t *plaintext = NULL, *ciphertext = NULL;
4518         unsigned int plaintext_pad_len;
4519         unsigned int plaintext_len;
4520         unsigned int ciphertext_pad_len;
4521         unsigned int ciphertext_len;
4522
4523         struct rte_cryptodev_info dev_info;
4524
4525         /* Verify the capabilities */
4526         struct rte_cryptodev_sym_capability_idx cap_idx;
4527         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4528         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4529         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4530                         &cap_idx) == NULL)
4531                 return -ENOTSUP;
4532         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4533         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4534         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4535                         &cap_idx) == NULL)
4536                 return -ENOTSUP;
4537
4538         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4539                 return -ENOTSUP;
4540
4541         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4542
4543         uint64_t feat_flags = dev_info.feature_flags;
4544
4545         if (op_mode == OUT_OF_PLACE) {
4546                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4547                         printf("Device doesn't support digest encrypted.\n");
4548                         return -ENOTSUP;
4549                 }
4550                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4551                         return -ENOTSUP;
4552         }
4553
4554         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4555                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4556                 printf("Device doesn't support RAW data-path APIs.\n");
4557                 return -ENOTSUP;
4558         }
4559
4560         /* Create SNOW 3G session */
4561         retval = create_wireless_algo_auth_cipher_session(
4562                         ts_params->valid_devs[0],
4563                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4564                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4565                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4566                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4567                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4568                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4569                         tdata->key.data, tdata->key.len,
4570                         tdata->auth_iv.len, tdata->digest.len,
4571                         tdata->cipher_iv.len);
4572
4573         if (retval < 0)
4574                 return retval;
4575
4576         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4577         if (op_mode == OUT_OF_PLACE)
4578                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4579
4580         /* clear mbuf payload */
4581         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4582                 rte_pktmbuf_tailroom(ut_params->ibuf));
4583         if (op_mode == OUT_OF_PLACE)
4584                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4585                         rte_pktmbuf_tailroom(ut_params->obuf));
4586
4587         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4588         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4589         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4590         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4591
4592         if (verify) {
4593                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4594                                         ciphertext_pad_len);
4595                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4596                 if (op_mode == OUT_OF_PLACE)
4597                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4598                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4599                         ciphertext_len);
4600         } else {
4601                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4602                                         plaintext_pad_len);
4603                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4604                 if (op_mode == OUT_OF_PLACE)
4605                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4606                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4607         }
4608
4609         /* Create SNOW 3G operation */
4610         retval = create_wireless_algo_auth_cipher_operation(
4611                 tdata->digest.data, tdata->digest.len,
4612                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4613                 tdata->auth_iv.data, tdata->auth_iv.len,
4614                 (tdata->digest.offset_bytes == 0 ?
4615                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4616                         : tdata->digest.offset_bytes),
4617                 tdata->validCipherLenInBits.len,
4618                 tdata->cipher.offset_bits,
4619                 tdata->validAuthLenInBits.len,
4620                 tdata->auth.offset_bits,
4621                 op_mode, 0, verify);
4622
4623         if (retval < 0)
4624                 return retval;
4625
4626         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4627                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4628                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4629         else
4630                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4631                         ut_params->op);
4632
4633         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4634
4635         ut_params->obuf = (op_mode == IN_PLACE ?
4636                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4637
4638         if (verify) {
4639                 if (ut_params->obuf)
4640                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
4641                                                         uint8_t *);
4642                 else
4643                         plaintext = ciphertext +
4644                                 (tdata->cipher.offset_bits >> 3);
4645
4646                 debug_hexdump(stdout, "plaintext:", plaintext,
4647                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4648                 debug_hexdump(stdout, "plaintext expected:",
4649                         tdata->plaintext.data,
4650                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4651         } else {
4652                 if (ut_params->obuf)
4653                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
4654                                                         uint8_t *);
4655                 else
4656                         ciphertext = plaintext;
4657
4658                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4659                         ciphertext_len);
4660                 debug_hexdump(stdout, "ciphertext expected:",
4661                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4662
4663                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4664                         + (tdata->digest.offset_bytes == 0 ?
4665                 plaintext_pad_len : tdata->digest.offset_bytes);
4666
4667                 debug_hexdump(stdout, "digest:", ut_params->digest,
4668                         tdata->digest.len);
4669                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
4670                                 tdata->digest.len);
4671         }
4672
4673         /* Validate obuf */
4674         if (verify) {
4675                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4676                         plaintext,
4677                         tdata->plaintext.data,
4678                         tdata->plaintext.len >> 3,
4679                         "SNOW 3G Plaintext data not as expected");
4680         } else {
4681                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4682                         ciphertext,
4683                         tdata->ciphertext.data,
4684                         tdata->validDataLenInBits.len,
4685                         "SNOW 3G Ciphertext data not as expected");
4686
4687                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4688                         ut_params->digest,
4689                         tdata->digest.data,
4690                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4691                         "SNOW 3G Generated auth tag not as expected");
4692         }
4693         return 0;
4694 }
4695
4696 static int
4697 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
4698         uint8_t op_mode, uint8_t verify)
4699 {
4700         struct crypto_testsuite_params *ts_params = &testsuite_params;
4701         struct crypto_unittest_params *ut_params = &unittest_params;
4702
4703         int retval;
4704
4705         const uint8_t *plaintext = NULL;
4706         const uint8_t *ciphertext = NULL;
4707         const uint8_t *digest = NULL;
4708         unsigned int plaintext_pad_len;
4709         unsigned int plaintext_len;
4710         unsigned int ciphertext_pad_len;
4711         unsigned int ciphertext_len;
4712         uint8_t buffer[10000];
4713         uint8_t digest_buffer[10000];
4714
4715         struct rte_cryptodev_info dev_info;
4716
4717         /* Verify the capabilities */
4718         struct rte_cryptodev_sym_capability_idx cap_idx;
4719         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4720         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4721         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4722                         &cap_idx) == NULL)
4723                 return -ENOTSUP;
4724         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4725         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4726         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4727                         &cap_idx) == NULL)
4728                 return -ENOTSUP;
4729
4730         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4731                 return -ENOTSUP;
4732
4733         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4734
4735         uint64_t feat_flags = dev_info.feature_flags;
4736
4737         if (op_mode == IN_PLACE) {
4738                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
4739                         printf("Device doesn't support in-place scatter-gather "
4740                                         "in both input and output mbufs.\n");
4741                         return -ENOTSUP;
4742                 }
4743                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4744                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4745                         printf("Device doesn't support RAW data-path APIs.\n");
4746                         return -ENOTSUP;
4747                 }
4748         } else {
4749                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4750                         return -ENOTSUP;
4751                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4752                         printf("Device doesn't support out-of-place scatter-gather "
4753                                         "in both input and output mbufs.\n");
4754                         return -ENOTSUP;
4755                 }
4756                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4757                         printf("Device doesn't support digest encrypted.\n");
4758                         return -ENOTSUP;
4759                 }
4760         }
4761
4762         /* Create SNOW 3G session */
4763         retval = create_wireless_algo_auth_cipher_session(
4764                         ts_params->valid_devs[0],
4765                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4766                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4767                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4768                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4769                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4770                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4771                         tdata->key.data, tdata->key.len,
4772                         tdata->auth_iv.len, tdata->digest.len,
4773                         tdata->cipher_iv.len);
4774
4775         if (retval < 0)
4776                 return retval;
4777
4778         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4779         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4780         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4781         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4782
4783         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4784                         plaintext_pad_len, 15, 0);
4785         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4786                         "Failed to allocate input buffer in mempool");
4787
4788         if (op_mode == OUT_OF_PLACE) {
4789                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4790                                 plaintext_pad_len, 15, 0);
4791                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
4792                                 "Failed to allocate output buffer in mempool");
4793         }
4794
4795         if (verify) {
4796                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
4797                         tdata->ciphertext.data);
4798                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4799                                         ciphertext_len, buffer);
4800                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4801                         ciphertext_len);
4802         } else {
4803                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
4804                         tdata->plaintext.data);
4805                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4806                                         plaintext_len, buffer);
4807                 debug_hexdump(stdout, "plaintext:", plaintext,
4808                         plaintext_len);
4809         }
4810         memset(buffer, 0, sizeof(buffer));
4811
4812         /* Create SNOW 3G operation */
4813         retval = create_wireless_algo_auth_cipher_operation(
4814                 tdata->digest.data, tdata->digest.len,
4815                 tdata->cipher_iv.data, tdata->cipher_iv.len,
4816                 tdata->auth_iv.data, tdata->auth_iv.len,
4817                 (tdata->digest.offset_bytes == 0 ?
4818                 (verify ? ciphertext_pad_len : plaintext_pad_len)
4819                         : tdata->digest.offset_bytes),
4820                 tdata->validCipherLenInBits.len,
4821                 tdata->cipher.offset_bits,
4822                 tdata->validAuthLenInBits.len,
4823                 tdata->auth.offset_bits,
4824                 op_mode, 1, verify);
4825
4826         if (retval < 0)
4827                 return retval;
4828
4829         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4830                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4831                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4832         else
4833                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4834                         ut_params->op);
4835
4836         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4837
4838         ut_params->obuf = (op_mode == IN_PLACE ?
4839                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
4840
4841         if (verify) {
4842                 if (ut_params->obuf)
4843                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
4844                                         plaintext_len, buffer);
4845                 else
4846                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
4847                                         plaintext_len, buffer);
4848
4849                 debug_hexdump(stdout, "plaintext:", plaintext,
4850                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4851                 debug_hexdump(stdout, "plaintext expected:",
4852                         tdata->plaintext.data,
4853                         (tdata->plaintext.len >> 3) - tdata->digest.len);
4854         } else {
4855                 if (ut_params->obuf)
4856                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4857                                         ciphertext_len, buffer);
4858                 else
4859                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4860                                         ciphertext_len, buffer);
4861
4862                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4863                         ciphertext_len);
4864                 debug_hexdump(stdout, "ciphertext expected:",
4865                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
4866
4867                 if (ut_params->obuf)
4868                         digest = rte_pktmbuf_read(ut_params->obuf,
4869                                 (tdata->digest.offset_bytes == 0 ?
4870                                 plaintext_pad_len : tdata->digest.offset_bytes),
4871                                 tdata->digest.len, digest_buffer);
4872                 else
4873                         digest = rte_pktmbuf_read(ut_params->ibuf,
4874                                 (tdata->digest.offset_bytes == 0 ?
4875                                 plaintext_pad_len : tdata->digest.offset_bytes),
4876                                 tdata->digest.len, digest_buffer);
4877
4878                 debug_hexdump(stdout, "digest:", digest,
4879                         tdata->digest.len);
4880                 debug_hexdump(stdout, "digest expected:",
4881                         tdata->digest.data, tdata->digest.len);
4882         }
4883
4884         /* Validate obuf */
4885         if (verify) {
4886                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4887                         plaintext,
4888                         tdata->plaintext.data,
4889                         tdata->plaintext.len >> 3,
4890                         "SNOW 3G Plaintext data not as expected");
4891         } else {
4892                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4893                         ciphertext,
4894                         tdata->ciphertext.data,
4895                         tdata->validDataLenInBits.len,
4896                         "SNOW 3G Ciphertext data not as expected");
4897
4898                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4899                         digest,
4900                         tdata->digest.data,
4901                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4902                         "SNOW 3G Generated auth tag not as expected");
4903         }
4904         return 0;
4905 }
4906
4907 static int
4908 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
4909         uint8_t op_mode, uint8_t verify)
4910 {
4911         struct crypto_testsuite_params *ts_params = &testsuite_params;
4912         struct crypto_unittest_params *ut_params = &unittest_params;
4913
4914         int retval;
4915
4916         uint8_t *plaintext = NULL, *ciphertext = NULL;
4917         unsigned int plaintext_pad_len;
4918         unsigned int plaintext_len;
4919         unsigned int ciphertext_pad_len;
4920         unsigned int ciphertext_len;
4921
4922         struct rte_cryptodev_info dev_info;
4923
4924         /* Verify the capabilities */
4925         struct rte_cryptodev_sym_capability_idx cap_idx;
4926         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4927         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
4928         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4929                         &cap_idx) == NULL)
4930                 return -ENOTSUP;
4931         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4932         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4933         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4934                         &cap_idx) == NULL)
4935                 return -ENOTSUP;
4936
4937         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4938
4939         uint64_t feat_flags = dev_info.feature_flags;
4940
4941         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4942                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4943                 printf("Device doesn't support RAW data-path APIs.\n");
4944                 return -ENOTSUP;
4945         }
4946
4947         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4948                 return -ENOTSUP;
4949
4950         if (op_mode == OUT_OF_PLACE) {
4951                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4952                         return -ENOTSUP;
4953                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
4954                         printf("Device doesn't support digest encrypted.\n");
4955                         return -ENOTSUP;
4956                 }
4957         }
4958
4959         /* Create KASUMI session */
4960         retval = create_wireless_algo_auth_cipher_session(
4961                         ts_params->valid_devs[0],
4962                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
4963                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
4964                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
4965                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
4966                         RTE_CRYPTO_AUTH_KASUMI_F9,
4967                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4968                         tdata->key.data, tdata->key.len,
4969                         0, tdata->digest.len,
4970                         tdata->cipher_iv.len);
4971
4972         if (retval < 0)
4973                 return retval;
4974
4975         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4976         if (op_mode == OUT_OF_PLACE)
4977                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4978
4979         /* clear mbuf payload */
4980         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4981                 rte_pktmbuf_tailroom(ut_params->ibuf));
4982         if (op_mode == OUT_OF_PLACE)
4983                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4984                         rte_pktmbuf_tailroom(ut_params->obuf));
4985
4986         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4987         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4988         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4989         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4990
4991         if (verify) {
4992                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4993                                         ciphertext_pad_len);
4994                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4995                 if (op_mode == OUT_OF_PLACE)
4996                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4997                 debug_hexdump(stdout, "ciphertext:", ciphertext,
4998                         ciphertext_len);
4999         } else {
5000                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5001                                         plaintext_pad_len);
5002                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5003                 if (op_mode == OUT_OF_PLACE)
5004                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5005                 debug_hexdump(stdout, "plaintext:", plaintext,
5006                         plaintext_len);
5007         }
5008
5009         /* Create KASUMI operation */
5010         retval = create_wireless_algo_auth_cipher_operation(
5011                 tdata->digest.data, tdata->digest.len,
5012                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5013                 NULL, 0,
5014                 (tdata->digest.offset_bytes == 0 ?
5015                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5016                         : tdata->digest.offset_bytes),
5017                 tdata->validCipherLenInBits.len,
5018                 tdata->validCipherOffsetInBits.len,
5019                 tdata->validAuthLenInBits.len,
5020                 0,
5021                 op_mode, 0, verify);
5022
5023         if (retval < 0)
5024                 return retval;
5025
5026         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5027                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5028                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5029         else
5030                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5031                         ut_params->op);
5032
5033         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5034
5035         ut_params->obuf = (op_mode == IN_PLACE ?
5036                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5037
5038
5039         if (verify) {
5040                 if (ut_params->obuf)
5041                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5042                                                         uint8_t *);
5043                 else
5044                         plaintext = ciphertext;
5045
5046                 debug_hexdump(stdout, "plaintext:", plaintext,
5047                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5048                 debug_hexdump(stdout, "plaintext expected:",
5049                         tdata->plaintext.data,
5050                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5051         } else {
5052                 if (ut_params->obuf)
5053                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5054                                                         uint8_t *);
5055                 else
5056                         ciphertext = plaintext;
5057
5058                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5059                         ciphertext_len);
5060                 debug_hexdump(stdout, "ciphertext expected:",
5061                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5062
5063                 ut_params->digest = rte_pktmbuf_mtod(
5064                         ut_params->obuf, uint8_t *) +
5065                         (tdata->digest.offset_bytes == 0 ?
5066                         plaintext_pad_len : tdata->digest.offset_bytes);
5067
5068                 debug_hexdump(stdout, "digest:", ut_params->digest,
5069                         tdata->digest.len);
5070                 debug_hexdump(stdout, "digest expected:",
5071                         tdata->digest.data, tdata->digest.len);
5072         }
5073
5074         /* Validate obuf */
5075         if (verify) {
5076                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5077                         plaintext,
5078                         tdata->plaintext.data,
5079                         tdata->plaintext.len >> 3,
5080                         "KASUMI Plaintext data not as expected");
5081         } else {
5082                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5083                         ciphertext,
5084                         tdata->ciphertext.data,
5085                         tdata->ciphertext.len >> 3,
5086                         "KASUMI Ciphertext data not as expected");
5087
5088                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5089                         ut_params->digest,
5090                         tdata->digest.data,
5091                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5092                         "KASUMI Generated auth tag not as expected");
5093         }
5094         return 0;
5095 }
5096
5097 static int
5098 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5099         uint8_t op_mode, uint8_t verify)
5100 {
5101         struct crypto_testsuite_params *ts_params = &testsuite_params;
5102         struct crypto_unittest_params *ut_params = &unittest_params;
5103
5104         int retval;
5105
5106         const uint8_t *plaintext = NULL;
5107         const uint8_t *ciphertext = NULL;
5108         const uint8_t *digest = NULL;
5109         unsigned int plaintext_pad_len;
5110         unsigned int plaintext_len;
5111         unsigned int ciphertext_pad_len;
5112         unsigned int ciphertext_len;
5113         uint8_t buffer[10000];
5114         uint8_t digest_buffer[10000];
5115
5116         struct rte_cryptodev_info dev_info;
5117
5118         /* Verify the capabilities */
5119         struct rte_cryptodev_sym_capability_idx cap_idx;
5120         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5121         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5122         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5123                         &cap_idx) == NULL)
5124                 return -ENOTSUP;
5125         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5126         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5127         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5128                         &cap_idx) == NULL)
5129                 return -ENOTSUP;
5130
5131         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5132                 return -ENOTSUP;
5133
5134         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5135
5136         uint64_t feat_flags = dev_info.feature_flags;
5137
5138         if (op_mode == IN_PLACE) {
5139                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5140                         printf("Device doesn't support in-place scatter-gather "
5141                                         "in both input and output mbufs.\n");
5142                         return -ENOTSUP;
5143                 }
5144                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5145                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5146                         printf("Device doesn't support RAW data-path APIs.\n");
5147                         return -ENOTSUP;
5148                 }
5149         } else {
5150                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5151                         return -ENOTSUP;
5152                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5153                         printf("Device doesn't support out-of-place scatter-gather "
5154                                         "in both input and output mbufs.\n");
5155                         return -ENOTSUP;
5156                 }
5157                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5158                         printf("Device doesn't support digest encrypted.\n");
5159                         return -ENOTSUP;
5160                 }
5161         }
5162
5163         /* Create KASUMI session */
5164         retval = create_wireless_algo_auth_cipher_session(
5165                         ts_params->valid_devs[0],
5166                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5167                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5168                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5169                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5170                         RTE_CRYPTO_AUTH_KASUMI_F9,
5171                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5172                         tdata->key.data, tdata->key.len,
5173                         0, tdata->digest.len,
5174                         tdata->cipher_iv.len);
5175
5176         if (retval < 0)
5177                 return retval;
5178
5179         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5180         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5181         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5182         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5183
5184         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5185                         plaintext_pad_len, 15, 0);
5186         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5187                         "Failed to allocate input buffer in mempool");
5188
5189         if (op_mode == OUT_OF_PLACE) {
5190                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5191                                 plaintext_pad_len, 15, 0);
5192                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5193                                 "Failed to allocate output buffer in mempool");
5194         }
5195
5196         if (verify) {
5197                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5198                         tdata->ciphertext.data);
5199                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5200                                         ciphertext_len, buffer);
5201                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5202                         ciphertext_len);
5203         } else {
5204                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5205                         tdata->plaintext.data);
5206                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5207                                         plaintext_len, buffer);
5208                 debug_hexdump(stdout, "plaintext:", plaintext,
5209                         plaintext_len);
5210         }
5211         memset(buffer, 0, sizeof(buffer));
5212
5213         /* Create KASUMI operation */
5214         retval = create_wireless_algo_auth_cipher_operation(
5215                 tdata->digest.data, tdata->digest.len,
5216                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5217                 NULL, 0,
5218                 (tdata->digest.offset_bytes == 0 ?
5219                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5220                         : tdata->digest.offset_bytes),
5221                 tdata->validCipherLenInBits.len,
5222                 tdata->validCipherOffsetInBits.len,
5223                 tdata->validAuthLenInBits.len,
5224                 0,
5225                 op_mode, 1, verify);
5226
5227         if (retval < 0)
5228                 return retval;
5229
5230         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5231                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5232                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5233         else
5234                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5235                         ut_params->op);
5236
5237         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5238
5239         ut_params->obuf = (op_mode == IN_PLACE ?
5240                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5241
5242         if (verify) {
5243                 if (ut_params->obuf)
5244                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5245                                         plaintext_len, buffer);
5246                 else
5247                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5248                                         plaintext_len, buffer);
5249
5250                 debug_hexdump(stdout, "plaintext:", plaintext,
5251                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5252                 debug_hexdump(stdout, "plaintext expected:",
5253                         tdata->plaintext.data,
5254                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5255         } else {
5256                 if (ut_params->obuf)
5257                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5258                                         ciphertext_len, buffer);
5259                 else
5260                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5261                                         ciphertext_len, buffer);
5262
5263                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5264                         ciphertext_len);
5265                 debug_hexdump(stdout, "ciphertext expected:",
5266                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5267
5268                 if (ut_params->obuf)
5269                         digest = rte_pktmbuf_read(ut_params->obuf,
5270                                 (tdata->digest.offset_bytes == 0 ?
5271                                 plaintext_pad_len : tdata->digest.offset_bytes),
5272                                 tdata->digest.len, digest_buffer);
5273                 else
5274                         digest = rte_pktmbuf_read(ut_params->ibuf,
5275                                 (tdata->digest.offset_bytes == 0 ?
5276                                 plaintext_pad_len : tdata->digest.offset_bytes),
5277                                 tdata->digest.len, digest_buffer);
5278
5279                 debug_hexdump(stdout, "digest:", digest,
5280                         tdata->digest.len);
5281                 debug_hexdump(stdout, "digest expected:",
5282                         tdata->digest.data, tdata->digest.len);
5283         }
5284
5285         /* Validate obuf */
5286         if (verify) {
5287                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5288                         plaintext,
5289                         tdata->plaintext.data,
5290                         tdata->plaintext.len >> 3,
5291                         "KASUMI Plaintext data not as expected");
5292         } else {
5293                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5294                         ciphertext,
5295                         tdata->ciphertext.data,
5296                         tdata->validDataLenInBits.len,
5297                         "KASUMI Ciphertext data not as expected");
5298
5299                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5300                         digest,
5301                         tdata->digest.data,
5302                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5303                         "KASUMI Generated auth tag not as expected");
5304         }
5305         return 0;
5306 }
5307
5308 static int
5309 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5310 {
5311         struct crypto_testsuite_params *ts_params = &testsuite_params;
5312         struct crypto_unittest_params *ut_params = &unittest_params;
5313
5314         int retval;
5315
5316         uint8_t *plaintext, *ciphertext;
5317         unsigned plaintext_pad_len;
5318         unsigned plaintext_len;
5319         struct rte_cryptodev_info dev_info;
5320
5321         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5322         uint64_t feat_flags = dev_info.feature_flags;
5323
5324         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5325                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5326                 printf("Device doesn't support RAW data-path APIs.\n");
5327                 return -ENOTSUP;
5328         }
5329
5330         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5331                 return -ENOTSUP;
5332
5333         /* Verify the capabilities */
5334         struct rte_cryptodev_sym_capability_idx cap_idx;
5335         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5336         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5337         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5338                         &cap_idx) == NULL)
5339                 return -ENOTSUP;
5340         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5341         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5342         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5343                         &cap_idx) == NULL)
5344                 return -ENOTSUP;
5345
5346         /* Create KASUMI session */
5347         retval = create_wireless_algo_cipher_auth_session(
5348                         ts_params->valid_devs[0],
5349                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5350                         RTE_CRYPTO_AUTH_OP_GENERATE,
5351                         RTE_CRYPTO_AUTH_KASUMI_F9,
5352                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5353                         tdata->key.data, tdata->key.len,
5354                         0, tdata->digest.len,
5355                         tdata->cipher_iv.len);
5356         if (retval < 0)
5357                 return retval;
5358
5359         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5360
5361         /* clear mbuf payload */
5362         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5363                         rte_pktmbuf_tailroom(ut_params->ibuf));
5364
5365         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5366         /* Append data which is padded to a multiple of */
5367         /* the algorithms block size */
5368         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5369         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5370                                 plaintext_pad_len);
5371         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5372
5373         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5374
5375         /* Create KASUMI operation */
5376         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5377                                 tdata->digest.len, NULL, 0,
5378                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5379                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5380                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5381                                 tdata->validCipherOffsetInBits.len,
5382                                 tdata->validAuthLenInBits.len,
5383                                 0
5384                                 );
5385         if (retval < 0)
5386                 return retval;
5387
5388         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5389                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5390                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5391         else
5392                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5393                         ut_params->op);
5394         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5395
5396         if (ut_params->op->sym->m_dst)
5397                 ut_params->obuf = ut_params->op->sym->m_dst;
5398         else
5399                 ut_params->obuf = ut_params->op->sym->m_src;
5400
5401         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5402                                 tdata->validCipherOffsetInBits.len >> 3);
5403
5404         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5405                         + plaintext_pad_len;
5406
5407         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5408                                 (tdata->validCipherOffsetInBits.len >> 3);
5409         /* Validate obuf */
5410         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5411                 ciphertext,
5412                 reference_ciphertext,
5413                 tdata->validCipherLenInBits.len,
5414                 "KASUMI Ciphertext data not as expected");
5415
5416         /* Validate obuf */
5417         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5418                 ut_params->digest,
5419                 tdata->digest.data,
5420                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5421                 "KASUMI Generated auth tag not as expected");
5422         return 0;
5423 }
5424
5425 static int
5426 test_zuc_encryption(const struct wireless_test_data *tdata)
5427 {
5428         struct crypto_testsuite_params *ts_params = &testsuite_params;
5429         struct crypto_unittest_params *ut_params = &unittest_params;
5430
5431         int retval;
5432         uint8_t *plaintext, *ciphertext;
5433         unsigned plaintext_pad_len;
5434         unsigned plaintext_len;
5435         struct rte_cryptodev_info dev_info;
5436
5437         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438         uint64_t feat_flags = dev_info.feature_flags;
5439
5440         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5441                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5442                 printf("Device doesn't support RAW data-path APIs.\n");
5443                 return -ENOTSUP;
5444         }
5445
5446         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5447                 return -ENOTSUP;
5448
5449         struct rte_cryptodev_sym_capability_idx cap_idx;
5450
5451         /* Check if device supports ZUC EEA3 */
5452         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5453         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5454
5455         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5456                         &cap_idx) == NULL)
5457                 return -ENOTSUP;
5458
5459         /* Create ZUC session */
5460         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5461                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5462                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5463                                         tdata->key.data, tdata->key.len,
5464                                         tdata->cipher_iv.len);
5465         if (retval < 0)
5466                 return retval;
5467
5468         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5469
5470         /* Clear mbuf payload */
5471         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5472                rte_pktmbuf_tailroom(ut_params->ibuf));
5473
5474         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5475         /* Append data which is padded to a multiple */
5476         /* of the algorithms block size */
5477         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5478         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5479                                 plaintext_pad_len);
5480         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5481
5482         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5483
5484         /* Create ZUC operation */
5485         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5486                                         tdata->cipher_iv.len,
5487                                         tdata->plaintext.len,
5488                                         0);
5489         if (retval < 0)
5490                 return retval;
5491
5492         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5493                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5494                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5495         else
5496                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5497                                                 ut_params->op);
5498         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5499
5500         ut_params->obuf = ut_params->op->sym->m_dst;
5501         if (ut_params->obuf)
5502                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
5503         else
5504                 ciphertext = plaintext;
5505
5506         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5507
5508         /* Validate obuf */
5509         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5510                 ciphertext,
5511                 tdata->ciphertext.data,
5512                 tdata->validCipherLenInBits.len,
5513                 "ZUC Ciphertext data not as expected");
5514         return 0;
5515 }
5516
5517 static int
5518 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
5519 {
5520         struct crypto_testsuite_params *ts_params = &testsuite_params;
5521         struct crypto_unittest_params *ut_params = &unittest_params;
5522
5523         int retval;
5524
5525         unsigned int plaintext_pad_len;
5526         unsigned int plaintext_len;
5527         const uint8_t *ciphertext;
5528         uint8_t ciphertext_buffer[2048];
5529         struct rte_cryptodev_info dev_info;
5530
5531         struct rte_cryptodev_sym_capability_idx cap_idx;
5532
5533         /* Check if device supports ZUC EEA3 */
5534         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5535         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
5536
5537         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5538                         &cap_idx) == NULL)
5539                 return -ENOTSUP;
5540
5541         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5542                 return -ENOTSUP;
5543
5544         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5545
5546         uint64_t feat_flags = dev_info.feature_flags;
5547
5548         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5549                 printf("Device doesn't support in-place scatter-gather. "
5550                                 "Test Skipped.\n");
5551                 return -ENOTSUP;
5552         }
5553
5554         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5555                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5556                 printf("Device doesn't support RAW data-path APIs.\n");
5557                 return -ENOTSUP;
5558         }
5559
5560         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5561
5562         /* Append data which is padded to a multiple */
5563         /* of the algorithms block size */
5564         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5565
5566         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5567                         plaintext_pad_len, 10, 0);
5568
5569         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5570                         tdata->plaintext.data);
5571
5572         /* Create ZUC session */
5573         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
5574                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5575                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5576                         tdata->key.data, tdata->key.len,
5577                         tdata->cipher_iv.len);
5578         if (retval < 0)
5579                 return retval;
5580
5581         /* Clear mbuf payload */
5582
5583         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
5584
5585         /* Create ZUC operation */
5586         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
5587                         tdata->cipher_iv.len, tdata->plaintext.len,
5588                         0);
5589         if (retval < 0)
5590                 return retval;
5591
5592         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5593                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5594                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
5595         else
5596                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5597                                                 ut_params->op);
5598         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5599
5600         ut_params->obuf = ut_params->op->sym->m_dst;
5601         if (ut_params->obuf)
5602                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
5603                         0, plaintext_len, ciphertext_buffer);
5604         else
5605                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
5606                         0, plaintext_len, ciphertext_buffer);
5607
5608         /* Validate obuf */
5609         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
5610
5611         /* Validate obuf */
5612         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5613                 ciphertext,
5614                 tdata->ciphertext.data,
5615                 tdata->validCipherLenInBits.len,
5616                 "ZUC Ciphertext data not as expected");
5617
5618         return 0;
5619 }
5620
5621 static int
5622 test_zuc_authentication(const struct wireless_test_data *tdata)
5623 {
5624         struct crypto_testsuite_params *ts_params = &testsuite_params;
5625         struct crypto_unittest_params *ut_params = &unittest_params;
5626
5627         int retval;
5628         unsigned plaintext_pad_len;
5629         unsigned plaintext_len;
5630         uint8_t *plaintext;
5631
5632         struct rte_cryptodev_sym_capability_idx cap_idx;
5633         struct rte_cryptodev_info dev_info;
5634
5635         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5636         uint64_t feat_flags = dev_info.feature_flags;
5637
5638         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
5639                         (tdata->validAuthLenInBits.len % 8 != 0)) {
5640                 printf("Device doesn't support NON-Byte Aligned Data.\n");
5641                 return -ENOTSUP;
5642         }
5643
5644         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646                 printf("Device doesn't support RAW data-path APIs.\n");
5647                 return -ENOTSUP;
5648         }
5649
5650         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5651                 return -ENOTSUP;
5652
5653         /* Check if device supports ZUC EIA3 */
5654         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5655         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5656
5657         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5658                         &cap_idx) == NULL)
5659                 return -ENOTSUP;
5660
5661         /* Create ZUC session */
5662         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
5663                         tdata->key.data, tdata->key.len,
5664                         tdata->auth_iv.len, tdata->digest.len,
5665                         RTE_CRYPTO_AUTH_OP_GENERATE,
5666                         RTE_CRYPTO_AUTH_ZUC_EIA3);
5667         if (retval < 0)
5668                 return retval;
5669
5670         /* alloc mbuf and set payload */
5671         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5672
5673         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5674         rte_pktmbuf_tailroom(ut_params->ibuf));
5675
5676         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5677         /* Append data which is padded to a multiple of */
5678         /* the algorithms block size */
5679         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
5680         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5681                                 plaintext_pad_len);
5682         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5683
5684         /* Create ZUC operation */
5685         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
5686                         tdata->auth_iv.data, tdata->auth_iv.len,
5687                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5688                         tdata->validAuthLenInBits.len,
5689                         0);
5690         if (retval < 0)
5691                 return retval;
5692
5693         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5694                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5695                                 ut_params->op, 0, 1, 1, 0);
5696         else
5697                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5698                                 ut_params->op);
5699         ut_params->obuf = ut_params->op->sym->m_src;
5700         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5701         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5702                         + plaintext_pad_len;
5703
5704         /* Validate obuf */
5705         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5706         ut_params->digest,
5707         tdata->digest.data,
5708         tdata->digest.len,
5709         "ZUC Generated auth tag not as expected");
5710
5711         return 0;
5712 }
5713
5714 static int
5715 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
5716         uint8_t op_mode, uint8_t verify)
5717 {
5718         struct crypto_testsuite_params *ts_params = &testsuite_params;
5719         struct crypto_unittest_params *ut_params = &unittest_params;
5720
5721         int retval;
5722
5723         uint8_t *plaintext = NULL, *ciphertext = NULL;
5724         unsigned int plaintext_pad_len;
5725         unsigned int plaintext_len;
5726         unsigned int ciphertext_pad_len;
5727         unsigned int ciphertext_len;
5728
5729         struct rte_cryptodev_info dev_info;
5730         struct rte_cryptodev_sym_capability_idx cap_idx;
5731
5732         /* Check if device supports ZUC EIA3 */
5733         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5734         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5735
5736         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5737                         &cap_idx) == NULL)
5738                 return -ENOTSUP;
5739
5740         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5741
5742         uint64_t feat_flags = dev_info.feature_flags;
5743
5744         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5745                 printf("Device doesn't support digest encrypted.\n");
5746                 return -ENOTSUP;
5747         }
5748         if (op_mode == IN_PLACE) {
5749                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5750                         printf("Device doesn't support in-place scatter-gather "
5751                                         "in both input and output mbufs.\n");
5752                         return -ENOTSUP;
5753                 }
5754
5755                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5756                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5757                         printf("Device doesn't support RAW data-path APIs.\n");
5758                         return -ENOTSUP;
5759                 }
5760         } else {
5761                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5762                         return -ENOTSUP;
5763                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5764                         printf("Device doesn't support out-of-place scatter-gather "
5765                                         "in both input and output mbufs.\n");
5766                         return -ENOTSUP;
5767                 }
5768         }
5769
5770         /* Create ZUC session */
5771         retval = create_wireless_algo_auth_cipher_session(
5772                         ts_params->valid_devs[0],
5773                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5774                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5775                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5776                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5777                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5778                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5779                         tdata->key.data, tdata->key.len,
5780                         tdata->auth_iv.len, tdata->digest.len,
5781                         tdata->cipher_iv.len);
5782
5783         if (retval < 0)
5784                 return retval;
5785
5786         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5787         if (op_mode == OUT_OF_PLACE)
5788                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5789
5790         /* clear mbuf payload */
5791         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5792                 rte_pktmbuf_tailroom(ut_params->ibuf));
5793         if (op_mode == OUT_OF_PLACE)
5794                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5795                         rte_pktmbuf_tailroom(ut_params->obuf));
5796
5797         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5798         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5799         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5800         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5801
5802         if (verify) {
5803                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5804                                         ciphertext_pad_len);
5805                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5806                 if (op_mode == OUT_OF_PLACE)
5807                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5808                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5809                         ciphertext_len);
5810         } else {
5811                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5812                                         plaintext_pad_len);
5813                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5814                 if (op_mode == OUT_OF_PLACE)
5815                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5816                 debug_hexdump(stdout, "plaintext:", plaintext,
5817                         plaintext_len);
5818         }
5819
5820         /* Create ZUC operation */
5821         retval = create_wireless_algo_auth_cipher_operation(
5822                 tdata->digest.data, tdata->digest.len,
5823                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5824                 tdata->auth_iv.data, tdata->auth_iv.len,
5825                 (tdata->digest.offset_bytes == 0 ?
5826                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5827                         : tdata->digest.offset_bytes),
5828                 tdata->validCipherLenInBits.len,
5829                 tdata->validCipherOffsetInBits.len,
5830                 tdata->validAuthLenInBits.len,
5831                 0,
5832                 op_mode, 0, verify);
5833
5834         if (retval < 0)
5835                 return retval;
5836
5837         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5838                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5839                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5840         else
5841                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5842                         ut_params->op);
5843
5844         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5845
5846         ut_params->obuf = (op_mode == IN_PLACE ?
5847                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5848
5849
5850         if (verify) {
5851                 if (ut_params->obuf)
5852                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5853                                                         uint8_t *);
5854                 else
5855                         plaintext = ciphertext;
5856
5857                 debug_hexdump(stdout, "plaintext:", plaintext,
5858                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5859                 debug_hexdump(stdout, "plaintext expected:",
5860                         tdata->plaintext.data,
5861                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5862         } else {
5863                 if (ut_params->obuf)
5864                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5865                                                         uint8_t *);
5866                 else
5867                         ciphertext = plaintext;
5868
5869                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5870                         ciphertext_len);
5871                 debug_hexdump(stdout, "ciphertext expected:",
5872                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5873
5874                 ut_params->digest = rte_pktmbuf_mtod(
5875                         ut_params->obuf, uint8_t *) +
5876                         (tdata->digest.offset_bytes == 0 ?
5877                         plaintext_pad_len : tdata->digest.offset_bytes);
5878
5879                 debug_hexdump(stdout, "digest:", ut_params->digest,
5880                         tdata->digest.len);
5881                 debug_hexdump(stdout, "digest expected:",
5882                         tdata->digest.data, tdata->digest.len);
5883         }
5884
5885         /* Validate obuf */
5886         if (verify) {
5887                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5888                         plaintext,
5889                         tdata->plaintext.data,
5890                         tdata->plaintext.len >> 3,
5891                         "ZUC Plaintext data not as expected");
5892         } else {
5893                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5894                         ciphertext,
5895                         tdata->ciphertext.data,
5896                         tdata->ciphertext.len >> 3,
5897                         "ZUC Ciphertext data not as expected");
5898
5899                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5900                         ut_params->digest,
5901                         tdata->digest.data,
5902                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5903                         "ZUC Generated auth tag not as expected");
5904         }
5905         return 0;
5906 }
5907
5908 static int
5909 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
5910         uint8_t op_mode, uint8_t verify)
5911 {
5912         struct crypto_testsuite_params *ts_params = &testsuite_params;
5913         struct crypto_unittest_params *ut_params = &unittest_params;
5914
5915         int retval;
5916
5917         const uint8_t *plaintext = NULL;
5918         const uint8_t *ciphertext = NULL;
5919         const uint8_t *digest = NULL;
5920         unsigned int plaintext_pad_len;
5921         unsigned int plaintext_len;
5922         unsigned int ciphertext_pad_len;
5923         unsigned int ciphertext_len;
5924         uint8_t buffer[10000];
5925         uint8_t digest_buffer[10000];
5926
5927         struct rte_cryptodev_info dev_info;
5928         struct rte_cryptodev_sym_capability_idx cap_idx;
5929
5930         /* Check if device supports ZUC EIA3 */
5931         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5932         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
5933
5934         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5935                         &cap_idx) == NULL)
5936                 return -ENOTSUP;
5937
5938         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5939
5940         uint64_t feat_flags = dev_info.feature_flags;
5941
5942         if (op_mode == IN_PLACE) {
5943                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5944                         printf("Device doesn't support in-place scatter-gather "
5945                                         "in both input and output mbufs.\n");
5946                         return -ENOTSUP;
5947                 }
5948
5949                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5950                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5951                         printf("Device doesn't support RAW data-path APIs.\n");
5952                         return -ENOTSUP;
5953                 }
5954         } else {
5955                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5956                         return -ENOTSUP;
5957                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5958                         printf("Device doesn't support out-of-place scatter-gather "
5959                                         "in both input and output mbufs.\n");
5960                         return -ENOTSUP;
5961                 }
5962                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5963                         printf("Device doesn't support digest encrypted.\n");
5964                         return -ENOTSUP;
5965                 }
5966         }
5967
5968         /* Create ZUC session */
5969         retval = create_wireless_algo_auth_cipher_session(
5970                         ts_params->valid_devs[0],
5971                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5972                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5973                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5974                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5975                         RTE_CRYPTO_AUTH_ZUC_EIA3,
5976                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
5977                         tdata->key.data, tdata->key.len,
5978                         tdata->auth_iv.len, tdata->digest.len,
5979                         tdata->cipher_iv.len);
5980
5981         if (retval < 0)
5982                 return retval;
5983
5984         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5985         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5986         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5987         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5988
5989         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5990                         plaintext_pad_len, 15, 0);
5991         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5992                         "Failed to allocate input buffer in mempool");
5993
5994         if (op_mode == OUT_OF_PLACE) {
5995                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5996                                 plaintext_pad_len, 15, 0);
5997                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5998                                 "Failed to allocate output buffer in mempool");
5999         }
6000
6001         if (verify) {
6002                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6003                         tdata->ciphertext.data);
6004                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6005                                         ciphertext_len, buffer);
6006                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6007                         ciphertext_len);
6008         } else {
6009                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6010                         tdata->plaintext.data);
6011                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6012                                         plaintext_len, buffer);
6013                 debug_hexdump(stdout, "plaintext:", plaintext,
6014                         plaintext_len);
6015         }
6016         memset(buffer, 0, sizeof(buffer));
6017
6018         /* Create ZUC operation */
6019         retval = create_wireless_algo_auth_cipher_operation(
6020                 tdata->digest.data, tdata->digest.len,
6021                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6022                 NULL, 0,
6023                 (tdata->digest.offset_bytes == 0 ?
6024                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6025                         : tdata->digest.offset_bytes),
6026                 tdata->validCipherLenInBits.len,
6027                 tdata->validCipherOffsetInBits.len,
6028                 tdata->validAuthLenInBits.len,
6029                 0,
6030                 op_mode, 1, verify);
6031
6032         if (retval < 0)
6033                 return retval;
6034
6035         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6036                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6037                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6038         else
6039                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6040                         ut_params->op);
6041
6042         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6043
6044         ut_params->obuf = (op_mode == IN_PLACE ?
6045                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6046
6047         if (verify) {
6048                 if (ut_params->obuf)
6049                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6050                                         plaintext_len, buffer);
6051                 else
6052                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6053                                         plaintext_len, buffer);
6054
6055                 debug_hexdump(stdout, "plaintext:", plaintext,
6056                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6057                 debug_hexdump(stdout, "plaintext expected:",
6058                         tdata->plaintext.data,
6059                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6060         } else {
6061                 if (ut_params->obuf)
6062                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6063                                         ciphertext_len, buffer);
6064                 else
6065                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6066                                         ciphertext_len, buffer);
6067
6068                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6069                         ciphertext_len);
6070                 debug_hexdump(stdout, "ciphertext expected:",
6071                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6072
6073                 if (ut_params->obuf)
6074                         digest = rte_pktmbuf_read(ut_params->obuf,
6075                                 (tdata->digest.offset_bytes == 0 ?
6076                                 plaintext_pad_len : tdata->digest.offset_bytes),
6077                                 tdata->digest.len, digest_buffer);
6078                 else
6079                         digest = rte_pktmbuf_read(ut_params->ibuf,
6080                                 (tdata->digest.offset_bytes == 0 ?
6081                                 plaintext_pad_len : tdata->digest.offset_bytes),
6082                                 tdata->digest.len, digest_buffer);
6083
6084                 debug_hexdump(stdout, "digest:", digest,
6085                         tdata->digest.len);
6086                 debug_hexdump(stdout, "digest expected:",
6087                         tdata->digest.data, tdata->digest.len);
6088         }
6089
6090         /* Validate obuf */
6091         if (verify) {
6092                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6093                         plaintext,
6094                         tdata->plaintext.data,
6095                         tdata->plaintext.len >> 3,
6096                         "ZUC Plaintext data not as expected");
6097         } else {
6098                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6099                         ciphertext,
6100                         tdata->ciphertext.data,
6101                         tdata->validDataLenInBits.len,
6102                         "ZUC Ciphertext data not as expected");
6103
6104                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6105                         digest,
6106                         tdata->digest.data,
6107                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6108                         "ZUC Generated auth tag not as expected");
6109         }
6110         return 0;
6111 }
6112
6113 static int
6114 test_kasumi_encryption_test_case_1(void)
6115 {
6116         return test_kasumi_encryption(&kasumi_test_case_1);
6117 }
6118
6119 static int
6120 test_kasumi_encryption_test_case_1_sgl(void)
6121 {
6122         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6123 }
6124
6125 static int
6126 test_kasumi_encryption_test_case_1_oop(void)
6127 {
6128         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6129 }
6130
6131 static int
6132 test_kasumi_encryption_test_case_1_oop_sgl(void)
6133 {
6134         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6135 }
6136
6137 static int
6138 test_kasumi_encryption_test_case_2(void)
6139 {
6140         return test_kasumi_encryption(&kasumi_test_case_2);
6141 }
6142
6143 static int
6144 test_kasumi_encryption_test_case_3(void)
6145 {
6146         return test_kasumi_encryption(&kasumi_test_case_3);
6147 }
6148
6149 static int
6150 test_kasumi_encryption_test_case_4(void)
6151 {
6152         return test_kasumi_encryption(&kasumi_test_case_4);
6153 }
6154
6155 static int
6156 test_kasumi_encryption_test_case_5(void)
6157 {
6158         return test_kasumi_encryption(&kasumi_test_case_5);
6159 }
6160
6161 static int
6162 test_kasumi_decryption_test_case_1(void)
6163 {
6164         return test_kasumi_decryption(&kasumi_test_case_1);
6165 }
6166
6167 static int
6168 test_kasumi_decryption_test_case_1_oop(void)
6169 {
6170         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6171 }
6172
6173 static int
6174 test_kasumi_decryption_test_case_2(void)
6175 {
6176         return test_kasumi_decryption(&kasumi_test_case_2);
6177 }
6178
6179 static int
6180 test_kasumi_decryption_test_case_3(void)
6181 {
6182         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6183         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6184                 return -ENOTSUP;
6185         return test_kasumi_decryption(&kasumi_test_case_3);
6186 }
6187
6188 static int
6189 test_kasumi_decryption_test_case_4(void)
6190 {
6191         return test_kasumi_decryption(&kasumi_test_case_4);
6192 }
6193
6194 static int
6195 test_kasumi_decryption_test_case_5(void)
6196 {
6197         return test_kasumi_decryption(&kasumi_test_case_5);
6198 }
6199 static int
6200 test_snow3g_encryption_test_case_1(void)
6201 {
6202         return test_snow3g_encryption(&snow3g_test_case_1);
6203 }
6204
6205 static int
6206 test_snow3g_encryption_test_case_1_oop(void)
6207 {
6208         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6209 }
6210
6211 static int
6212 test_snow3g_encryption_test_case_1_oop_sgl(void)
6213 {
6214         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6215 }
6216
6217
6218 static int
6219 test_snow3g_encryption_test_case_1_offset_oop(void)
6220 {
6221         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6222 }
6223
6224 static int
6225 test_snow3g_encryption_test_case_2(void)
6226 {
6227         return test_snow3g_encryption(&snow3g_test_case_2);
6228 }
6229
6230 static int
6231 test_snow3g_encryption_test_case_3(void)
6232 {
6233         return test_snow3g_encryption(&snow3g_test_case_3);
6234 }
6235
6236 static int
6237 test_snow3g_encryption_test_case_4(void)
6238 {
6239         return test_snow3g_encryption(&snow3g_test_case_4);
6240 }
6241
6242 static int
6243 test_snow3g_encryption_test_case_5(void)
6244 {
6245         return test_snow3g_encryption(&snow3g_test_case_5);
6246 }
6247
6248 static int
6249 test_snow3g_decryption_test_case_1(void)
6250 {
6251         return test_snow3g_decryption(&snow3g_test_case_1);
6252 }
6253
6254 static int
6255 test_snow3g_decryption_test_case_1_oop(void)
6256 {
6257         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6258 }
6259
6260 static int
6261 test_snow3g_decryption_test_case_2(void)
6262 {
6263         return test_snow3g_decryption(&snow3g_test_case_2);
6264 }
6265
6266 static int
6267 test_snow3g_decryption_test_case_3(void)
6268 {
6269         return test_snow3g_decryption(&snow3g_test_case_3);
6270 }
6271
6272 static int
6273 test_snow3g_decryption_test_case_4(void)
6274 {
6275         return test_snow3g_decryption(&snow3g_test_case_4);
6276 }
6277
6278 static int
6279 test_snow3g_decryption_test_case_5(void)
6280 {
6281         return test_snow3g_decryption(&snow3g_test_case_5);
6282 }
6283
6284 /*
6285  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6286  * Pattern digest from snow3g_test_data must be allocated as
6287  * 4 last bytes in plaintext.
6288  */
6289 static void
6290 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6291                 struct snow3g_hash_test_data *output)
6292 {
6293         if ((pattern != NULL) && (output != NULL)) {
6294                 output->key.len = pattern->key.len;
6295
6296                 memcpy(output->key.data,
6297                 pattern->key.data, pattern->key.len);
6298
6299                 output->auth_iv.len = pattern->auth_iv.len;
6300
6301                 memcpy(output->auth_iv.data,
6302                 pattern->auth_iv.data, pattern->auth_iv.len);
6303
6304                 output->plaintext.len = pattern->plaintext.len;
6305
6306                 memcpy(output->plaintext.data,
6307                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6308
6309                 output->digest.len = pattern->digest.len;
6310
6311                 memcpy(output->digest.data,
6312                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6313                 pattern->digest.len);
6314
6315                 output->validAuthLenInBits.len =
6316                 pattern->validAuthLenInBits.len;
6317         }
6318 }
6319
6320 /*
6321  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6322  */
6323 static int
6324 test_snow3g_decryption_with_digest_test_case_1(void)
6325 {
6326         struct snow3g_hash_test_data snow3g_hash_data;
6327
6328         /*
6329          * Function prepare data for hash veryfication test case.
6330          * Digest is allocated in 4 last bytes in plaintext, pattern.
6331          */
6332         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6333
6334         return test_snow3g_decryption(&snow3g_test_case_7) &
6335                         test_snow3g_authentication_verify(&snow3g_hash_data);
6336 }
6337
6338 static int
6339 test_snow3g_cipher_auth_test_case_1(void)
6340 {
6341         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6342 }
6343
6344 static int
6345 test_snow3g_auth_cipher_test_case_1(void)
6346 {
6347         return test_snow3g_auth_cipher(
6348                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6349 }
6350
6351 static int
6352 test_snow3g_auth_cipher_test_case_2(void)
6353 {
6354         return test_snow3g_auth_cipher(
6355                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6356 }
6357
6358 static int
6359 test_snow3g_auth_cipher_test_case_2_oop(void)
6360 {
6361         return test_snow3g_auth_cipher(
6362                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6363 }
6364
6365 static int
6366 test_snow3g_auth_cipher_part_digest_enc(void)
6367 {
6368         return test_snow3g_auth_cipher(
6369                 &snow3g_auth_cipher_partial_digest_encryption,
6370                         IN_PLACE, 0);
6371 }
6372
6373 static int
6374 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6375 {
6376         return test_snow3g_auth_cipher(
6377                 &snow3g_auth_cipher_partial_digest_encryption,
6378                         OUT_OF_PLACE, 0);
6379 }
6380
6381 static int
6382 test_snow3g_auth_cipher_test_case_3_sgl(void)
6383 {
6384         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6385         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6386                 return -ENOTSUP;
6387         return test_snow3g_auth_cipher_sgl(
6388                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6389 }
6390
6391 static int
6392 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6393 {
6394         return test_snow3g_auth_cipher_sgl(
6395                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6396 }
6397
6398 static int
6399 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6400 {
6401         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6402         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6403                 return -ENOTSUP;
6404         return test_snow3g_auth_cipher_sgl(
6405                 &snow3g_auth_cipher_partial_digest_encryption,
6406                         IN_PLACE, 0);
6407 }
6408
6409 static int
6410 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6411 {
6412         return test_snow3g_auth_cipher_sgl(
6413                 &snow3g_auth_cipher_partial_digest_encryption,
6414                         OUT_OF_PLACE, 0);
6415 }
6416
6417 static int
6418 test_snow3g_auth_cipher_verify_test_case_1(void)
6419 {
6420         return test_snow3g_auth_cipher(
6421                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6422 }
6423
6424 static int
6425 test_snow3g_auth_cipher_verify_test_case_2(void)
6426 {
6427         return test_snow3g_auth_cipher(
6428                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6429 }
6430
6431 static int
6432 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6433 {
6434         return test_snow3g_auth_cipher(
6435                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6436 }
6437
6438 static int
6439 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6440 {
6441         return test_snow3g_auth_cipher(
6442                 &snow3g_auth_cipher_partial_digest_encryption,
6443                         IN_PLACE, 1);
6444 }
6445
6446 static int
6447 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6448 {
6449         return test_snow3g_auth_cipher(
6450                 &snow3g_auth_cipher_partial_digest_encryption,
6451                         OUT_OF_PLACE, 1);
6452 }
6453
6454 static int
6455 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
6456 {
6457         return test_snow3g_auth_cipher_sgl(
6458                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
6459 }
6460
6461 static int
6462 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
6463 {
6464         return test_snow3g_auth_cipher_sgl(
6465                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
6466 }
6467
6468 static int
6469 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
6470 {
6471         return test_snow3g_auth_cipher_sgl(
6472                 &snow3g_auth_cipher_partial_digest_encryption,
6473                         IN_PLACE, 1);
6474 }
6475
6476 static int
6477 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
6478 {
6479         return test_snow3g_auth_cipher_sgl(
6480                 &snow3g_auth_cipher_partial_digest_encryption,
6481                         OUT_OF_PLACE, 1);
6482 }
6483
6484 static int
6485 test_snow3g_auth_cipher_with_digest_test_case_1(void)
6486 {
6487         return test_snow3g_auth_cipher(
6488                 &snow3g_test_case_7, IN_PLACE, 0);
6489 }
6490
6491 static int
6492 test_kasumi_auth_cipher_test_case_1(void)
6493 {
6494         return test_kasumi_auth_cipher(
6495                 &kasumi_test_case_3, IN_PLACE, 0);
6496 }
6497
6498 static int
6499 test_kasumi_auth_cipher_test_case_2(void)
6500 {
6501         return test_kasumi_auth_cipher(
6502                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6503 }
6504
6505 static int
6506 test_kasumi_auth_cipher_test_case_2_oop(void)
6507 {
6508         return test_kasumi_auth_cipher(
6509                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6510 }
6511
6512 static int
6513 test_kasumi_auth_cipher_test_case_2_sgl(void)
6514 {
6515         return test_kasumi_auth_cipher_sgl(
6516                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
6517 }
6518
6519 static int
6520 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
6521 {
6522         return test_kasumi_auth_cipher_sgl(
6523                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6524 }
6525
6526 static int
6527 test_kasumi_auth_cipher_verify_test_case_1(void)
6528 {
6529         return test_kasumi_auth_cipher(
6530                 &kasumi_test_case_3, IN_PLACE, 1);
6531 }
6532
6533 static int
6534 test_kasumi_auth_cipher_verify_test_case_2(void)
6535 {
6536         return test_kasumi_auth_cipher(
6537                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6538 }
6539
6540 static int
6541 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
6542 {
6543         return test_kasumi_auth_cipher(
6544                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6545 }
6546
6547 static int
6548 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
6549 {
6550         return test_kasumi_auth_cipher_sgl(
6551                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
6552 }
6553
6554 static int
6555 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
6556 {
6557         return test_kasumi_auth_cipher_sgl(
6558                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6559 }
6560
6561 static int
6562 test_kasumi_cipher_auth_test_case_1(void)
6563 {
6564         return test_kasumi_cipher_auth(&kasumi_test_case_6);
6565 }
6566
6567 static int
6568 test_zuc_encryption_test_case_1(void)
6569 {
6570         return test_zuc_encryption(&zuc_test_case_cipher_193b);
6571 }
6572
6573 static int
6574 test_zuc_encryption_test_case_2(void)
6575 {
6576         return test_zuc_encryption(&zuc_test_case_cipher_800b);
6577 }
6578
6579 static int
6580 test_zuc_encryption_test_case_3(void)
6581 {
6582         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
6583 }
6584
6585 static int
6586 test_zuc_encryption_test_case_4(void)
6587 {
6588         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
6589 }
6590
6591 static int
6592 test_zuc_encryption_test_case_5(void)
6593 {
6594         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
6595 }
6596
6597 static int
6598 test_zuc_encryption_test_case_6_sgl(void)
6599 {
6600         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
6601 }
6602
6603 static int
6604 test_zuc_hash_generate_test_case_1(void)
6605 {
6606         return test_zuc_authentication(&zuc_test_case_auth_1b);
6607 }
6608
6609 static int
6610 test_zuc_hash_generate_test_case_2(void)
6611 {
6612         return test_zuc_authentication(&zuc_test_case_auth_90b);
6613 }
6614
6615 static int
6616 test_zuc_hash_generate_test_case_3(void)
6617 {
6618         return test_zuc_authentication(&zuc_test_case_auth_577b);
6619 }
6620
6621 static int
6622 test_zuc_hash_generate_test_case_4(void)
6623 {
6624         return test_zuc_authentication(&zuc_test_case_auth_2079b);
6625 }
6626
6627 static int
6628 test_zuc_hash_generate_test_case_5(void)
6629 {
6630         return test_zuc_authentication(&zuc_test_auth_5670b);
6631 }
6632
6633 static int
6634 test_zuc_hash_generate_test_case_6(void)
6635 {
6636         return test_zuc_authentication(&zuc_test_case_auth_128b);
6637 }
6638
6639 static int
6640 test_zuc_hash_generate_test_case_7(void)
6641 {
6642         return test_zuc_authentication(&zuc_test_case_auth_2080b);
6643 }
6644
6645 static int
6646 test_zuc_hash_generate_test_case_8(void)
6647 {
6648         return test_zuc_authentication(&zuc_test_case_auth_584b);
6649 }
6650
6651 static int
6652 test_zuc_cipher_auth_test_case_1(void)
6653 {
6654         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
6655 }
6656
6657 static int
6658 test_zuc_cipher_auth_test_case_2(void)
6659 {
6660         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
6661 }
6662
6663 static int
6664 test_zuc_auth_cipher_test_case_1(void)
6665 {
6666         return test_zuc_auth_cipher(
6667                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6668 }
6669
6670 static int
6671 test_zuc_auth_cipher_test_case_1_oop(void)
6672 {
6673         return test_zuc_auth_cipher(
6674                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6675 }
6676
6677 static int
6678 test_zuc_auth_cipher_test_case_1_sgl(void)
6679 {
6680         return test_zuc_auth_cipher_sgl(
6681                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
6682 }
6683
6684 static int
6685 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
6686 {
6687         return test_zuc_auth_cipher_sgl(
6688                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
6689 }
6690
6691 static int
6692 test_zuc_auth_cipher_verify_test_case_1(void)
6693 {
6694         return test_zuc_auth_cipher(
6695                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6696 }
6697
6698 static int
6699 test_zuc_auth_cipher_verify_test_case_1_oop(void)
6700 {
6701         return test_zuc_auth_cipher(
6702                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6703 }
6704
6705 static int
6706 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
6707 {
6708         return test_zuc_auth_cipher_sgl(
6709                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
6710 }
6711
6712 static int
6713 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
6714 {
6715         return test_zuc_auth_cipher_sgl(
6716                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
6717 }
6718
6719 static int
6720 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
6721 {
6722         uint8_t dev_id = testsuite_params.valid_devs[0];
6723
6724         struct rte_cryptodev_sym_capability_idx cap_idx;
6725
6726         /* Check if device supports particular cipher algorithm */
6727         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
6728         cap_idx.algo.cipher = tdata->cipher_algo;
6729         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6730                 return -ENOTSUP;
6731
6732         /* Check if device supports particular hash algorithm */
6733         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
6734         cap_idx.algo.auth = tdata->auth_algo;
6735         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
6736                 return -ENOTSUP;
6737
6738         return 0;
6739 }
6740
6741 static int
6742 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
6743         uint8_t op_mode, uint8_t verify)
6744 {
6745         struct crypto_testsuite_params *ts_params = &testsuite_params;
6746         struct crypto_unittest_params *ut_params = &unittest_params;
6747
6748         int retval;
6749
6750         uint8_t *plaintext = NULL, *ciphertext = NULL;
6751         unsigned int plaintext_pad_len;
6752         unsigned int plaintext_len;
6753         unsigned int ciphertext_pad_len;
6754         unsigned int ciphertext_len;
6755
6756         struct rte_cryptodev_info dev_info;
6757         struct rte_crypto_op *op;
6758
6759         /* Check if device supports particular algorithms separately */
6760         if (test_mixed_check_if_unsupported(tdata))
6761                 return -ENOTSUP;
6762         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6763                 return -ENOTSUP;
6764
6765         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6766
6767         uint64_t feat_flags = dev_info.feature_flags;
6768
6769         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6770                 printf("Device doesn't support digest encrypted.\n");
6771                 return -ENOTSUP;
6772         }
6773
6774         /* Create the session */
6775         if (verify)
6776                 retval = create_wireless_algo_cipher_auth_session(
6777                                 ts_params->valid_devs[0],
6778                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6779                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6780                                 tdata->auth_algo,
6781                                 tdata->cipher_algo,
6782                                 tdata->auth_key.data, tdata->auth_key.len,
6783                                 tdata->auth_iv.len, tdata->digest_enc.len,
6784                                 tdata->cipher_iv.len);
6785         else
6786                 retval = create_wireless_algo_auth_cipher_session(
6787                                 ts_params->valid_devs[0],
6788                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6789                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6790                                 tdata->auth_algo,
6791                                 tdata->cipher_algo,
6792                                 tdata->auth_key.data, tdata->auth_key.len,
6793                                 tdata->auth_iv.len, tdata->digest_enc.len,
6794                                 tdata->cipher_iv.len);
6795         if (retval < 0)
6796                 return retval;
6797
6798         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6799         if (op_mode == OUT_OF_PLACE)
6800                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6801
6802         /* clear mbuf payload */
6803         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6804                 rte_pktmbuf_tailroom(ut_params->ibuf));
6805         if (op_mode == OUT_OF_PLACE) {
6806
6807                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6808                                 rte_pktmbuf_tailroom(ut_params->obuf));
6809         }
6810
6811         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
6812         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
6813         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6814         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6815
6816         if (verify) {
6817                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6818                                 ciphertext_pad_len);
6819                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6820                 if (op_mode == OUT_OF_PLACE)
6821                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6822                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6823                                 ciphertext_len);
6824         } else {
6825                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6826                                 plaintext_pad_len);
6827                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6828                 if (op_mode == OUT_OF_PLACE)
6829                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
6830                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6831         }
6832
6833         /* Create the operation */
6834         retval = create_wireless_algo_auth_cipher_operation(
6835                         tdata->digest_enc.data, tdata->digest_enc.len,
6836                         tdata->cipher_iv.data, tdata->cipher_iv.len,
6837                         tdata->auth_iv.data, tdata->auth_iv.len,
6838                         (tdata->digest_enc.offset == 0 ?
6839                                 plaintext_pad_len
6840                                 : tdata->digest_enc.offset),
6841                         tdata->validCipherLen.len_bits,
6842                         tdata->cipher.offset_bits,
6843                         tdata->validAuthLen.len_bits,
6844                         tdata->auth.offset_bits,
6845                         op_mode, 0, verify);
6846
6847         if (retval < 0)
6848                 return retval;
6849
6850         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
6851
6852         /* Check if the op failed because the device doesn't */
6853         /* support this particular combination of algorithms */
6854         if (op == NULL && ut_params->op->status ==
6855                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
6856                 printf("Device doesn't support this mixed combination. "
6857                                 "Test Skipped.\n");
6858                 return -ENOTSUP;
6859         }
6860         ut_params->op = op;
6861
6862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6863
6864         ut_params->obuf = (op_mode == IN_PLACE ?
6865                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6866
6867         if (verify) {
6868                 if (ut_params->obuf)
6869                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6870                                                         uint8_t *);
6871                 else
6872                         plaintext = ciphertext +
6873                                         (tdata->cipher.offset_bits >> 3);
6874
6875                 debug_hexdump(stdout, "plaintext:", plaintext,
6876                                 tdata->plaintext.len_bits >> 3);
6877                 debug_hexdump(stdout, "plaintext expected:",
6878                                 tdata->plaintext.data,
6879                                 tdata->plaintext.len_bits >> 3);
6880         } else {
6881                 if (ut_params->obuf)
6882                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6883                                         uint8_t *);
6884                 else
6885                         ciphertext = plaintext;
6886
6887                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6888                                 ciphertext_len);
6889                 debug_hexdump(stdout, "ciphertext expected:",
6890                                 tdata->ciphertext.data,
6891                                 tdata->ciphertext.len_bits >> 3);
6892
6893                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6894                                 + (tdata->digest_enc.offset == 0 ?
6895                 plaintext_pad_len : tdata->digest_enc.offset);
6896
6897                 debug_hexdump(stdout, "digest:", ut_params->digest,
6898                                 tdata->digest_enc.len);
6899                 debug_hexdump(stdout, "digest expected:",
6900                                 tdata->digest_enc.data,
6901                                 tdata->digest_enc.len);
6902         }
6903
6904         /* Validate obuf */
6905         if (verify) {
6906                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6907                                 plaintext,
6908                                 tdata->plaintext.data,
6909                                 tdata->plaintext.len_bits >> 3,
6910                                 "Plaintext data not as expected");
6911         } else {
6912                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6913                                 ciphertext,
6914                                 tdata->ciphertext.data,
6915                                 tdata->validDataLen.len_bits,
6916                                 "Ciphertext data not as expected");
6917
6918                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6919                                 ut_params->digest,
6920                                 tdata->digest_enc.data,
6921                                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
6922                                 "Generated auth tag not as expected");
6923         }
6924
6925         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
6926                         "crypto op processing failed");
6927
6928         return 0;
6929 }
6930
6931 static int
6932 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
6933         uint8_t op_mode, uint8_t verify)
6934 {
6935         struct crypto_testsuite_params *ts_params = &testsuite_params;
6936         struct crypto_unittest_params *ut_params = &unittest_params;
6937
6938         int retval;
6939
6940         const uint8_t *plaintext = NULL;
6941         const uint8_t *ciphertext = NULL;
6942         const uint8_t *digest = NULL;
6943         unsigned int plaintext_pad_len;
6944         unsigned int plaintext_len;
6945         unsigned int ciphertext_pad_len;
6946         unsigned int ciphertext_len;
6947         uint8_t buffer[10000];
6948         uint8_t digest_buffer[10000];
6949
6950         struct rte_cryptodev_info dev_info;
6951         struct rte_crypto_op *op;
6952
6953         /* Check if device supports particular algorithms */
6954         if (test_mixed_check_if_unsupported(tdata))
6955                 return -ENOTSUP;
6956         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6957                 return -ENOTSUP;
6958
6959         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6960
6961         uint64_t feat_flags = dev_info.feature_flags;
6962
6963         if (op_mode == IN_PLACE) {
6964                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6965                         printf("Device doesn't support in-place scatter-gather "
6966                                         "in both input and output mbufs.\n");
6967                         return -ENOTSUP;
6968                 }
6969         } else {
6970                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6971                         printf("Device doesn't support out-of-place scatter-gather "
6972                                         "in both input and output mbufs.\n");
6973                         return -ENOTSUP;
6974                 }
6975                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6976                         printf("Device doesn't support digest encrypted.\n");
6977                         return -ENOTSUP;
6978                 }
6979         }
6980
6981         /* Create the session */
6982         if (verify)
6983                 retval = create_wireless_algo_cipher_auth_session(
6984                                 ts_params->valid_devs[0],
6985                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
6986                                 RTE_CRYPTO_AUTH_OP_VERIFY,
6987                                 tdata->auth_algo,
6988                                 tdata->cipher_algo,
6989                                 tdata->auth_key.data, tdata->auth_key.len,
6990                                 tdata->auth_iv.len, tdata->digest_enc.len,
6991                                 tdata->cipher_iv.len);
6992         else
6993                 retval = create_wireless_algo_auth_cipher_session(
6994                                 ts_params->valid_devs[0],
6995                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6996                                 RTE_CRYPTO_AUTH_OP_GENERATE,
6997                                 tdata->auth_algo,
6998                                 tdata->cipher_algo,
6999                                 tdata->auth_key.data, tdata->auth_key.len,
7000                                 tdata->auth_iv.len, tdata->digest_enc.len,
7001                                 tdata->cipher_iv.len);
7002         if (retval < 0)
7003                 return retval;
7004
7005         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7006         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7007         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7008         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7009
7010         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7011                         ciphertext_pad_len, 15, 0);
7012         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7013                         "Failed to allocate input buffer in mempool");
7014
7015         if (op_mode == OUT_OF_PLACE) {
7016                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7017                                 plaintext_pad_len, 15, 0);
7018                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7019                                 "Failed to allocate output buffer in mempool");
7020         }
7021
7022         if (verify) {
7023                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7024                         tdata->ciphertext.data);
7025                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7026                                         ciphertext_len, buffer);
7027                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7028                         ciphertext_len);
7029         } else {
7030                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7031                         tdata->plaintext.data);
7032                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7033                                         plaintext_len, buffer);
7034                 debug_hexdump(stdout, "plaintext:", plaintext,
7035                         plaintext_len);
7036         }
7037         memset(buffer, 0, sizeof(buffer));
7038
7039         /* Create the operation */
7040         retval = create_wireless_algo_auth_cipher_operation(
7041                         tdata->digest_enc.data, tdata->digest_enc.len,
7042                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7043                         tdata->auth_iv.data, tdata->auth_iv.len,
7044                         (tdata->digest_enc.offset == 0 ?
7045                                 plaintext_pad_len
7046                                 : tdata->digest_enc.offset),
7047                         tdata->validCipherLen.len_bits,
7048                         tdata->cipher.offset_bits,
7049                         tdata->validAuthLen.len_bits,
7050                         tdata->auth.offset_bits,
7051                         op_mode, 1, verify);
7052
7053         if (retval < 0)
7054                 return retval;
7055
7056         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7057
7058         /* Check if the op failed because the device doesn't */
7059         /* support this particular combination of algorithms */
7060         if (op == NULL && ut_params->op->status ==
7061                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7062                 printf("Device doesn't support this mixed combination. "
7063                                 "Test Skipped.\n");
7064                 return -ENOTSUP;
7065         }
7066         ut_params->op = op;
7067
7068         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7069
7070         ut_params->obuf = (op_mode == IN_PLACE ?
7071                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7072
7073         if (verify) {
7074                 if (ut_params->obuf)
7075                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7076                                         plaintext_len, buffer);
7077                 else
7078                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7079                                         plaintext_len, buffer);
7080
7081                 debug_hexdump(stdout, "plaintext:", plaintext,
7082                                 (tdata->plaintext.len_bits >> 3) -
7083                                 tdata->digest_enc.len);
7084                 debug_hexdump(stdout, "plaintext expected:",
7085                                 tdata->plaintext.data,
7086                                 (tdata->plaintext.len_bits >> 3) -
7087                                 tdata->digest_enc.len);
7088         } else {
7089                 if (ut_params->obuf)
7090                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7091                                         ciphertext_len, buffer);
7092                 else
7093                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7094                                         ciphertext_len, buffer);
7095
7096                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7097                         ciphertext_len);
7098                 debug_hexdump(stdout, "ciphertext expected:",
7099                         tdata->ciphertext.data,
7100                         tdata->ciphertext.len_bits >> 3);
7101
7102                 if (ut_params->obuf)
7103                         digest = rte_pktmbuf_read(ut_params->obuf,
7104                                         (tdata->digest_enc.offset == 0 ?
7105                                                 plaintext_pad_len :
7106                                                 tdata->digest_enc.offset),
7107                                         tdata->digest_enc.len, digest_buffer);
7108                 else
7109                         digest = rte_pktmbuf_read(ut_params->ibuf,
7110                                         (tdata->digest_enc.offset == 0 ?
7111                                                 plaintext_pad_len :
7112                                                 tdata->digest_enc.offset),
7113                                         tdata->digest_enc.len, digest_buffer);
7114
7115                 debug_hexdump(stdout, "digest:", digest,
7116                                 tdata->digest_enc.len);
7117                 debug_hexdump(stdout, "digest expected:",
7118                                 tdata->digest_enc.data, tdata->digest_enc.len);
7119         }
7120
7121         /* Validate obuf */
7122         if (verify) {
7123                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7124                                 plaintext,
7125                                 tdata->plaintext.data,
7126                                 tdata->plaintext.len_bits >> 3,
7127                                 "Plaintext data not as expected");
7128         } else {
7129                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7130                                 ciphertext,
7131                                 tdata->ciphertext.data,
7132                                 tdata->validDataLen.len_bits,
7133                                 "Ciphertext data not as expected");
7134                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7135                                 digest,
7136                                 tdata->digest_enc.data,
7137                                 tdata->digest_enc.len,
7138                                 "Generated auth tag not as expected");
7139         }
7140
7141         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7142                         "crypto op processing failed");
7143
7144         return 0;
7145 }
7146
7147 /** AUTH AES CMAC + CIPHER AES CTR */
7148
7149 static int
7150 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7151 {
7152         return test_mixed_auth_cipher(
7153                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7154 }
7155
7156 static int
7157 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7158 {
7159         return test_mixed_auth_cipher(
7160                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7161 }
7162
7163 static int
7164 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7165 {
7166         return test_mixed_auth_cipher_sgl(
7167                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7168 }
7169
7170 static int
7171 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7172 {
7173         return test_mixed_auth_cipher_sgl(
7174                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7175 }
7176
7177 static int
7178 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7179 {
7180         return test_mixed_auth_cipher(
7181                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7182 }
7183
7184 static int
7185 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7186 {
7187         return test_mixed_auth_cipher(
7188                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7189 }
7190
7191 static int
7192 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7193 {
7194         return test_mixed_auth_cipher_sgl(
7195                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7196 }
7197
7198 static int
7199 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7200 {
7201         return test_mixed_auth_cipher_sgl(
7202                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7203 }
7204
7205 /** MIXED AUTH + CIPHER */
7206
7207 static int
7208 test_auth_zuc_cipher_snow_test_case_1(void)
7209 {
7210         return test_mixed_auth_cipher(
7211                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7212 }
7213
7214 static int
7215 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7216 {
7217         return test_mixed_auth_cipher(
7218                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7219 }
7220
7221 static int
7222 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7223 {
7224         return test_mixed_auth_cipher(
7225                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7226 }
7227
7228 static int
7229 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7230 {
7231         return test_mixed_auth_cipher(
7232                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7233 }
7234
7235 static int
7236 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7237 {
7238         return test_mixed_auth_cipher(
7239                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7240 }
7241
7242 static int
7243 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7244 {
7245         return test_mixed_auth_cipher(
7246                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7247 }
7248
7249 static int
7250 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7251 {
7252         return test_mixed_auth_cipher(
7253                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7254 }
7255
7256 static int
7257 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7258 {
7259         return test_mixed_auth_cipher(
7260                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7261 }
7262
7263 static int
7264 test_auth_snow_cipher_zuc_test_case_1(void)
7265 {
7266         return test_mixed_auth_cipher(
7267                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7268 }
7269
7270 static int
7271 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7272 {
7273         return test_mixed_auth_cipher(
7274                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7275 }
7276
7277 static int
7278 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7279 {
7280         return test_mixed_auth_cipher(
7281                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7282 }
7283
7284 static int
7285 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7286 {
7287         return test_mixed_auth_cipher(
7288                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7289 }
7290
7291 static int
7292 test_auth_null_cipher_snow_test_case_1(void)
7293 {
7294         return test_mixed_auth_cipher(
7295                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7296 }
7297
7298 static int
7299 test_verify_auth_null_cipher_snow_test_case_1(void)
7300 {
7301         return test_mixed_auth_cipher(
7302                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7303 }
7304
7305 static int
7306 test_auth_null_cipher_zuc_test_case_1(void)
7307 {
7308         return test_mixed_auth_cipher(
7309                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7310 }
7311
7312 static int
7313 test_verify_auth_null_cipher_zuc_test_case_1(void)
7314 {
7315         return test_mixed_auth_cipher(
7316                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7317 }
7318
7319 static int
7320 test_auth_snow_cipher_null_test_case_1(void)
7321 {
7322         return test_mixed_auth_cipher(
7323                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7324 }
7325
7326 static int
7327 test_verify_auth_snow_cipher_null_test_case_1(void)
7328 {
7329         return test_mixed_auth_cipher(
7330                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7331 }
7332
7333 static int
7334 test_auth_zuc_cipher_null_test_case_1(void)
7335 {
7336         return test_mixed_auth_cipher(
7337                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7338 }
7339
7340 static int
7341 test_verify_auth_zuc_cipher_null_test_case_1(void)
7342 {
7343         return test_mixed_auth_cipher(
7344                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7345 }
7346
7347 static int
7348 test_auth_null_cipher_aes_ctr_test_case_1(void)
7349 {
7350         return test_mixed_auth_cipher(
7351                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7352 }
7353
7354 static int
7355 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7356 {
7357         return test_mixed_auth_cipher(
7358                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7359 }
7360
7361 static int
7362 test_auth_aes_cmac_cipher_null_test_case_1(void)
7363 {
7364         return test_mixed_auth_cipher(
7365                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7366 }
7367
7368 static int
7369 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7370 {
7371         return test_mixed_auth_cipher(
7372                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7373 }
7374
7375 /* ***** AEAD algorithm Tests ***** */
7376
7377 static int
7378 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7379                 enum rte_crypto_aead_operation op,
7380                 const uint8_t *key, const uint8_t key_len,
7381                 const uint16_t aad_len, const uint8_t auth_len,
7382                 uint8_t iv_len)
7383 {
7384         uint8_t aead_key[key_len];
7385
7386         struct crypto_testsuite_params *ts_params = &testsuite_params;
7387         struct crypto_unittest_params *ut_params = &unittest_params;
7388
7389         memcpy(aead_key, key, key_len);
7390
7391         /* Setup AEAD Parameters */
7392         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7393         ut_params->aead_xform.next = NULL;
7394         ut_params->aead_xform.aead.algo = algo;
7395         ut_params->aead_xform.aead.op = op;
7396         ut_params->aead_xform.aead.key.data = aead_key;
7397         ut_params->aead_xform.aead.key.length = key_len;
7398         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7399         ut_params->aead_xform.aead.iv.length = iv_len;
7400         ut_params->aead_xform.aead.digest_length = auth_len;
7401         ut_params->aead_xform.aead.aad_length = aad_len;
7402
7403         debug_hexdump(stdout, "key:", key, key_len);
7404
7405         /* Create Crypto session*/
7406         ut_params->sess = rte_cryptodev_sym_session_create(
7407                         ts_params->session_mpool);
7408
7409         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
7410                         &ut_params->aead_xform,
7411                         ts_params->session_priv_mpool);
7412
7413         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
7414
7415         return 0;
7416 }
7417
7418 static int
7419 create_aead_xform(struct rte_crypto_op *op,
7420                 enum rte_crypto_aead_algorithm algo,
7421                 enum rte_crypto_aead_operation aead_op,
7422                 uint8_t *key, const uint8_t key_len,
7423                 const uint8_t aad_len, const uint8_t auth_len,
7424                 uint8_t iv_len)
7425 {
7426         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
7427                         "failed to allocate space for crypto transform");
7428
7429         struct rte_crypto_sym_op *sym_op = op->sym;
7430
7431         /* Setup AEAD Parameters */
7432         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
7433         sym_op->xform->next = NULL;
7434         sym_op->xform->aead.algo = algo;
7435         sym_op->xform->aead.op = aead_op;
7436         sym_op->xform->aead.key.data = key;
7437         sym_op->xform->aead.key.length = key_len;
7438         sym_op->xform->aead.iv.offset = IV_OFFSET;
7439         sym_op->xform->aead.iv.length = iv_len;
7440         sym_op->xform->aead.digest_length = auth_len;
7441         sym_op->xform->aead.aad_length = aad_len;
7442
7443         debug_hexdump(stdout, "key:", key, key_len);
7444
7445         return 0;
7446 }
7447
7448 static int
7449 create_aead_operation(enum rte_crypto_aead_operation op,
7450                 const struct aead_test_data *tdata)
7451 {
7452         struct crypto_testsuite_params *ts_params = &testsuite_params;
7453         struct crypto_unittest_params *ut_params = &unittest_params;
7454
7455         uint8_t *plaintext, *ciphertext;
7456         unsigned int aad_pad_len, plaintext_pad_len;
7457
7458         /* Generate Crypto op data structure */
7459         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7460                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7461         TEST_ASSERT_NOT_NULL(ut_params->op,
7462                         "Failed to allocate symmetric crypto operation struct");
7463
7464         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
7465
7466         /* Append aad data */
7467         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
7468                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
7469                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7470                                 aad_pad_len);
7471                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7472                                 "no room to append aad");
7473
7474                 sym_op->aead.aad.phys_addr =
7475                                 rte_pktmbuf_iova(ut_params->ibuf);
7476                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
7477                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
7478                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7479                         tdata->aad.len);
7480
7481                 /* Append IV at the end of the crypto operation*/
7482                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7483                                 uint8_t *, IV_OFFSET);
7484
7485                 /* Copy IV 1 byte after the IV pointer, according to the API */
7486                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
7487                 debug_hexdump(stdout, "iv:", iv_ptr,
7488                         tdata->iv.len);
7489         } else {
7490                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
7491                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7492                                 aad_pad_len);
7493                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
7494                                 "no room to append aad");
7495
7496                 sym_op->aead.aad.phys_addr =
7497                                 rte_pktmbuf_iova(ut_params->ibuf);
7498                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
7499                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
7500                         tdata->aad.len);
7501
7502                 /* Append IV at the end of the crypto operation*/
7503                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
7504                                 uint8_t *, IV_OFFSET);
7505
7506                 if (tdata->iv.len == 0) {
7507                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
7508                         debug_hexdump(stdout, "iv:", iv_ptr,
7509                                 AES_GCM_J0_LENGTH);
7510                 } else {
7511                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
7512                         debug_hexdump(stdout, "iv:", iv_ptr,
7513                                 tdata->iv.len);
7514                 }
7515         }
7516
7517         /* Append plaintext/ciphertext */
7518         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7519                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7520                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7521                                 plaintext_pad_len);
7522                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
7523
7524                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
7525                 debug_hexdump(stdout, "plaintext:", plaintext,
7526                                 tdata->plaintext.len);
7527
7528                 if (ut_params->obuf) {
7529                         ciphertext = (uint8_t *)rte_pktmbuf_append(
7530                                         ut_params->obuf,
7531                                         plaintext_pad_len + aad_pad_len);
7532                         TEST_ASSERT_NOT_NULL(ciphertext,
7533                                         "no room to append ciphertext");
7534
7535                         memset(ciphertext + aad_pad_len, 0,
7536                                         tdata->ciphertext.len);
7537                 }
7538         } else {
7539                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
7540                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7541                                 plaintext_pad_len);
7542                 TEST_ASSERT_NOT_NULL(ciphertext,
7543                                 "no room to append ciphertext");
7544
7545                 memcpy(ciphertext, tdata->ciphertext.data,
7546                                 tdata->ciphertext.len);
7547                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7548                                 tdata->ciphertext.len);
7549
7550                 if (ut_params->obuf) {
7551                         plaintext = (uint8_t *)rte_pktmbuf_append(
7552                                         ut_params->obuf,
7553                                         plaintext_pad_len + aad_pad_len);
7554                         TEST_ASSERT_NOT_NULL(plaintext,
7555                                         "no room to append plaintext");
7556
7557                         memset(plaintext + aad_pad_len, 0,
7558                                         tdata->plaintext.len);
7559                 }
7560         }
7561
7562         /* Append digest data */
7563         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
7564                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7565                                 ut_params->obuf ? ut_params->obuf :
7566                                                 ut_params->ibuf,
7567                                                 tdata->auth_tag.len);
7568                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7569                                 "no room to append digest");
7570                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
7571                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7572                                 ut_params->obuf ? ut_params->obuf :
7573                                                 ut_params->ibuf,
7574                                                 plaintext_pad_len +
7575                                                 aad_pad_len);
7576         } else {
7577                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
7578                                 ut_params->ibuf, tdata->auth_tag.len);
7579                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
7580                                 "no room to append digest");
7581                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
7582                                 ut_params->ibuf,
7583                                 plaintext_pad_len + aad_pad_len);
7584
7585                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
7586                         tdata->auth_tag.len);
7587                 debug_hexdump(stdout, "digest:",
7588                         sym_op->aead.digest.data,
7589                         tdata->auth_tag.len);
7590         }
7591
7592         sym_op->aead.data.length = tdata->plaintext.len;
7593         sym_op->aead.data.offset = aad_pad_len;
7594
7595         return 0;
7596 }
7597
7598 static int
7599 test_authenticated_encryption(const struct aead_test_data *tdata)
7600 {
7601         struct crypto_testsuite_params *ts_params = &testsuite_params;
7602         struct crypto_unittest_params *ut_params = &unittest_params;
7603
7604         int retval;
7605         uint8_t *ciphertext, *auth_tag;
7606         uint16_t plaintext_pad_len;
7607         uint32_t i;
7608         struct rte_cryptodev_info dev_info;
7609
7610         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7611         uint64_t feat_flags = dev_info.feature_flags;
7612
7613         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
7614                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
7615                 printf("Device doesn't support RAW data-path APIs.\n");
7616                 return -ENOTSUP;
7617         }
7618
7619         /* Verify the capabilities */
7620         struct rte_cryptodev_sym_capability_idx cap_idx;
7621         const struct rte_cryptodev_symmetric_capability *capability;
7622         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7623         cap_idx.algo.aead = tdata->algo;
7624         capability = rte_cryptodev_sym_capability_get(
7625                         ts_params->valid_devs[0], &cap_idx);
7626         if (capability == NULL)
7627                 return -ENOTSUP;
7628         if (rte_cryptodev_sym_capability_check_aead(
7629                         capability, tdata->key.len, tdata->auth_tag.len,
7630                         tdata->aad.len, tdata->iv.len))
7631                 return -ENOTSUP;
7632
7633         /* Create AEAD session */
7634         retval = create_aead_session(ts_params->valid_devs[0],
7635                         tdata->algo,
7636                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
7637                         tdata->key.data, tdata->key.len,
7638                         tdata->aad.len, tdata->auth_tag.len,
7639                         tdata->iv.len);
7640         if (retval < 0)
7641                 return retval;
7642
7643         if (tdata->aad.len > MBUF_SIZE) {
7644                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
7645                 /* Populate full size of add data */
7646                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
7647                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
7648         } else
7649                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7650
7651         /* clear mbuf payload */
7652         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7653                         rte_pktmbuf_tailroom(ut_params->ibuf));
7654
7655         /* Create AEAD operation */
7656         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
7657         if (retval < 0)
7658                 return retval;
7659
7660         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
7661
7662         ut_params->op->sym->m_src = ut_params->ibuf;
7663
7664         /* Process crypto operation */
7665         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
7666                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
7667         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7668                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
7669                                 ut_params->op, 0, 0, 0, 0);
7670         else
7671                 TEST_ASSERT_NOT_NULL(
7672                         process_crypto_request(ts_params->valid_devs[0],
7673                         ut_params->op), "failed to process sym crypto op");
7674
7675         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7676                         "crypto op processing failed");
7677
7678         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
7679
7680         if (ut_params->op->sym->m_dst) {
7681                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7682                                 uint8_t *);
7683                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
7684                                 uint8_t *, plaintext_pad_len);
7685         } else {
7686                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
7687                                 uint8_t *,
7688                                 ut_params->op->sym->cipher.data.offset);
7689                 auth_tag = ciphertext + plaintext_pad_len;
7690         }
7691
7692         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
7693         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
7694
7695         /* Validate obuf */
7696         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7697                         ciphertext,
7698                         tdata->ciphertext.data,
7699                         tdata->ciphertext.len,
7700                         "Ciphertext data not as expected");
7701
7702         TEST_ASSERT_BUFFERS_ARE_EQUAL(
7703                         auth_tag,
7704                         tdata->auth_tag.data,
7705                         tdata->auth_tag.len,
7706                         "Generated auth tag not as expected");
7707
7708         return 0;
7709
7710 }
7711
7712 #ifdef RTE_LIB_SECURITY
7713 static int
7714 security_proto_supported(enum rte_security_session_action_type action,
7715         enum rte_security_session_protocol proto)
7716 {
7717         struct crypto_testsuite_params *ts_params = &testsuite_params;
7718
7719         const struct rte_security_capability *capabilities;
7720         const struct rte_security_capability *capability;
7721         uint16_t i = 0;
7722
7723         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7724                                 rte_cryptodev_get_sec_ctx(
7725                                 ts_params->valid_devs[0]);
7726
7727
7728         capabilities = rte_security_capabilities_get(ctx);
7729
7730         if (capabilities == NULL)
7731                 return -ENOTSUP;
7732
7733         while ((capability = &capabilities[i++])->action !=
7734                         RTE_SECURITY_ACTION_TYPE_NONE) {
7735                 if (capability->action == action &&
7736                                 capability->protocol == proto)
7737                         return 0;
7738         }
7739
7740         return -ENOTSUP;
7741 }
7742
7743 /* Basic algorithm run function for async inplace mode.
7744  * Creates a session from input parameters and runs one operation
7745  * on input_vec. Checks the output of the crypto operation against
7746  * output_vec.
7747  */
7748 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
7749                            enum rte_crypto_auth_operation opa,
7750                            const uint8_t *input_vec, unsigned int input_vec_len,
7751                            const uint8_t *output_vec,
7752                            unsigned int output_vec_len,
7753                            enum rte_crypto_cipher_algorithm cipher_alg,
7754                            const uint8_t *cipher_key, uint32_t cipher_key_len,
7755                            enum rte_crypto_auth_algorithm auth_alg,
7756                            const uint8_t *auth_key, uint32_t auth_key_len,
7757                            uint8_t bearer, enum rte_security_pdcp_domain domain,
7758                            uint8_t packet_direction, uint8_t sn_size,
7759                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
7760 {
7761         struct crypto_testsuite_params *ts_params = &testsuite_params;
7762         struct crypto_unittest_params *ut_params = &unittest_params;
7763         uint8_t *plaintext;
7764         int ret = TEST_SUCCESS;
7765         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7766                                 rte_cryptodev_get_sec_ctx(
7767                                 ts_params->valid_devs[0]);
7768
7769         /* Verify the capabilities */
7770         struct rte_security_capability_idx sec_cap_idx;
7771
7772         sec_cap_idx.action = ut_params->type;
7773         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7774         sec_cap_idx.pdcp.domain = domain;
7775         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7776                 return -ENOTSUP;
7777
7778         /* Generate test mbuf data */
7779         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7780
7781         /* clear mbuf payload */
7782         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7783                         rte_pktmbuf_tailroom(ut_params->ibuf));
7784
7785         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7786                                                   input_vec_len);
7787         memcpy(plaintext, input_vec, input_vec_len);
7788
7789         /* Out of place support */
7790         if (oop) {
7791                 /*
7792                  * For out-op-place we need to alloc another mbuf
7793                  */
7794                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7795                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
7796         }
7797
7798         /* Setup Cipher Parameters */
7799         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7800         ut_params->cipher_xform.cipher.algo = cipher_alg;
7801         ut_params->cipher_xform.cipher.op = opc;
7802         ut_params->cipher_xform.cipher.key.data = cipher_key;
7803         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
7804         ut_params->cipher_xform.cipher.iv.length =
7805                                 packet_direction ? 4 : 0;
7806         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
7807
7808         /* Setup HMAC Parameters if ICV header is required */
7809         if (auth_alg != 0) {
7810                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7811                 ut_params->auth_xform.next = NULL;
7812                 ut_params->auth_xform.auth.algo = auth_alg;
7813                 ut_params->auth_xform.auth.op = opa;
7814                 ut_params->auth_xform.auth.key.data = auth_key;
7815                 ut_params->auth_xform.auth.key.length = auth_key_len;
7816
7817                 ut_params->cipher_xform.next = &ut_params->auth_xform;
7818         } else {
7819                 ut_params->cipher_xform.next = NULL;
7820         }
7821
7822         struct rte_security_session_conf sess_conf = {
7823                 .action_type = ut_params->type,
7824                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
7825                 {.pdcp = {
7826                         .bearer = bearer,
7827                         .domain = domain,
7828                         .pkt_dir = packet_direction,
7829                         .sn_size = sn_size,
7830                         .hfn = packet_direction ? 0 : hfn,
7831                         /**
7832                          * hfn can be set as pdcp_test_hfn[i]
7833                          * if hfn_ovrd is not set. Here, PDCP
7834                          * packet direction is just used to
7835                          * run half of the cases with session
7836                          * HFN and other half with per packet
7837                          * HFN.
7838                          */
7839                         .hfn_threshold = hfn_threshold,
7840                         .hfn_ovrd = packet_direction ? 1 : 0,
7841                         .sdap_enabled = sdap,
7842                 } },
7843                 .crypto_xform = &ut_params->cipher_xform
7844         };
7845
7846         /* Create security session */
7847         ut_params->sec_session = rte_security_session_create(ctx,
7848                                 &sess_conf, ts_params->session_mpool,
7849                                 ts_params->session_priv_mpool);
7850
7851         if (!ut_params->sec_session) {
7852                 printf("TestCase %s()-%d line %d failed %s: ",
7853                         __func__, i, __LINE__, "Failed to allocate session");
7854                 ret = TEST_FAILED;
7855                 goto on_err;
7856         }
7857
7858         /* Generate crypto op data structure */
7859         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
7860                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
7861         if (!ut_params->op) {
7862                 printf("TestCase %s()-%d line %d failed %s: ",
7863                         __func__, i, __LINE__,
7864                         "Failed to allocate symmetric crypto operation struct");
7865                 ret = TEST_FAILED;
7866                 goto on_err;
7867         }
7868
7869         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
7870                                         uint32_t *, IV_OFFSET);
7871         *per_pkt_hfn = packet_direction ? hfn : 0;
7872
7873         rte_security_attach_session(ut_params->op, ut_params->sec_session);
7874
7875         /* set crypto operation source mbuf */
7876         ut_params->op->sym->m_src = ut_params->ibuf;
7877         if (oop)
7878                 ut_params->op->sym->m_dst = ut_params->obuf;
7879
7880         /* Process crypto operation */
7881         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
7882                 == NULL) {
7883                 printf("TestCase %s()-%d line %d failed %s: ",
7884                         __func__, i, __LINE__,
7885                         "failed to process sym crypto op");
7886                 ret = TEST_FAILED;
7887                 goto on_err;
7888         }
7889
7890         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
7891                 printf("TestCase %s()-%d line %d failed %s: ",
7892                         __func__, i, __LINE__, "crypto op processing failed");
7893                 ret = TEST_FAILED;
7894                 goto on_err;
7895         }
7896
7897         /* Validate obuf */
7898         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
7899                         uint8_t *);
7900         if (oop) {
7901                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
7902                                 uint8_t *);
7903         }
7904
7905         if (memcmp(ciphertext, output_vec, output_vec_len)) {
7906                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
7907                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
7908                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
7909                 ret = TEST_FAILED;
7910                 goto on_err;
7911         }
7912
7913 on_err:
7914         rte_crypto_op_free(ut_params->op);
7915         ut_params->op = NULL;
7916
7917         if (ut_params->sec_session)
7918                 rte_security_session_destroy(ctx, ut_params->sec_session);
7919         ut_params->sec_session = NULL;
7920
7921         rte_pktmbuf_free(ut_params->ibuf);
7922         ut_params->ibuf = NULL;
7923         if (oop) {
7924                 rte_pktmbuf_free(ut_params->obuf);
7925                 ut_params->obuf = NULL;
7926         }
7927
7928         return ret;
7929 }
7930
7931 static int
7932 test_pdcp_proto_SGL(int i, int oop,
7933         enum rte_crypto_cipher_operation opc,
7934         enum rte_crypto_auth_operation opa,
7935         uint8_t *input_vec,
7936         unsigned int input_vec_len,
7937         uint8_t *output_vec,
7938         unsigned int output_vec_len,
7939         uint32_t fragsz,
7940         uint32_t fragsz_oop)
7941 {
7942         struct crypto_testsuite_params *ts_params = &testsuite_params;
7943         struct crypto_unittest_params *ut_params = &unittest_params;
7944         uint8_t *plaintext;
7945         struct rte_mbuf *buf, *buf_oop = NULL;
7946         int ret = TEST_SUCCESS;
7947         int to_trn = 0;
7948         int to_trn_tbl[16];
7949         int segs = 1;
7950         unsigned int trn_data = 0;
7951         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
7952                                 rte_cryptodev_get_sec_ctx(
7953                                 ts_params->valid_devs[0]);
7954
7955         /* Verify the capabilities */
7956         struct rte_security_capability_idx sec_cap_idx;
7957
7958         sec_cap_idx.action = ut_params->type;
7959         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
7960         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
7961         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
7962                 return -ENOTSUP;
7963
7964         if (fragsz > input_vec_len)
7965                 fragsz = input_vec_len;
7966
7967         uint16_t plaintext_len = fragsz;
7968         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
7969
7970         if (fragsz_oop > output_vec_len)
7971                 frag_size_oop = output_vec_len;
7972
7973         int ecx = 0;
7974         if (input_vec_len % fragsz != 0) {
7975                 if (input_vec_len / fragsz + 1 > 16)
7976                         return 1;
7977         } else if (input_vec_len / fragsz > 16)
7978                 return 1;
7979
7980         /* Out of place support */
7981         if (oop) {
7982                 /*
7983                  * For out-op-place we need to alloc another mbuf
7984                  */
7985                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7986                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
7987                 buf_oop = ut_params->obuf;
7988         }
7989
7990         /* Generate test mbuf data */
7991         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7992
7993         /* clear mbuf payload */
7994         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7995                         rte_pktmbuf_tailroom(ut_params->ibuf));
7996
7997         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7998                                                   plaintext_len);
7999         memcpy(plaintext, input_vec, plaintext_len);
8000         trn_data += plaintext_len;
8001
8002         buf = ut_params->ibuf;
8003
8004         /*
8005          * Loop until no more fragments
8006          */
8007
8008         while (trn_data < input_vec_len) {
8009                 ++segs;
8010                 to_trn = (input_vec_len - trn_data < fragsz) ?
8011                                 (input_vec_len - trn_data) : fragsz;
8012
8013                 to_trn_tbl[ecx++] = to_trn;
8014
8015                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8016                 buf = buf->next;
8017
8018                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8019                                 rte_pktmbuf_tailroom(buf));
8020
8021                 /* OOP */
8022                 if (oop && !fragsz_oop) {
8023                         buf_oop->next =
8024                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8025                         buf_oop = buf_oop->next;
8026                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8027                                         0, rte_pktmbuf_tailroom(buf_oop));
8028                         rte_pktmbuf_append(buf_oop, to_trn);
8029                 }
8030
8031                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8032                                 to_trn);
8033
8034                 memcpy(plaintext, input_vec + trn_data, to_trn);
8035                 trn_data += to_trn;
8036         }
8037
8038         ut_params->ibuf->nb_segs = segs;
8039
8040         segs = 1;
8041         if (fragsz_oop && oop) {
8042                 to_trn = 0;
8043                 ecx = 0;
8044
8045                 trn_data = frag_size_oop;
8046                 while (trn_data < output_vec_len) {
8047                         ++segs;
8048                         to_trn =
8049                                 (output_vec_len - trn_data <
8050                                                 frag_size_oop) ?
8051                                 (output_vec_len - trn_data) :
8052                                                 frag_size_oop;
8053
8054                         to_trn_tbl[ecx++] = to_trn;
8055
8056                         buf_oop->next =
8057                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8058                         buf_oop = buf_oop->next;
8059                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8060                                         0, rte_pktmbuf_tailroom(buf_oop));
8061                         rte_pktmbuf_append(buf_oop, to_trn);
8062
8063                         trn_data += to_trn;
8064                 }
8065                 ut_params->obuf->nb_segs = segs;
8066         }
8067
8068         /* Setup Cipher Parameters */
8069         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8070         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8071         ut_params->cipher_xform.cipher.op = opc;
8072         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8073         ut_params->cipher_xform.cipher.key.length =
8074                                         pdcp_test_params[i].cipher_key_len;
8075         ut_params->cipher_xform.cipher.iv.length = 0;
8076
8077         /* Setup HMAC Parameters if ICV header is required */
8078         if (pdcp_test_params[i].auth_alg != 0) {
8079                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8080                 ut_params->auth_xform.next = NULL;
8081                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8082                 ut_params->auth_xform.auth.op = opa;
8083                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8084                 ut_params->auth_xform.auth.key.length =
8085                                         pdcp_test_params[i].auth_key_len;
8086
8087                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8088         } else {
8089                 ut_params->cipher_xform.next = NULL;
8090         }
8091
8092         struct rte_security_session_conf sess_conf = {
8093                 .action_type = ut_params->type,
8094                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8095                 {.pdcp = {
8096                         .bearer = pdcp_test_bearer[i],
8097                         .domain = pdcp_test_params[i].domain,
8098                         .pkt_dir = pdcp_test_packet_direction[i],
8099                         .sn_size = pdcp_test_data_sn_size[i],
8100                         .hfn = pdcp_test_hfn[i],
8101                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8102                         .hfn_ovrd = 0,
8103                 } },
8104                 .crypto_xform = &ut_params->cipher_xform
8105         };
8106
8107         /* Create security session */
8108         ut_params->sec_session = rte_security_session_create(ctx,
8109                                 &sess_conf, ts_params->session_mpool,
8110                                 ts_params->session_priv_mpool);
8111
8112         if (!ut_params->sec_session) {
8113                 printf("TestCase %s()-%d line %d failed %s: ",
8114                         __func__, i, __LINE__, "Failed to allocate session");
8115                 ret = TEST_FAILED;
8116                 goto on_err;
8117         }
8118
8119         /* Generate crypto op data structure */
8120         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8121                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8122         if (!ut_params->op) {
8123                 printf("TestCase %s()-%d line %d failed %s: ",
8124                         __func__, i, __LINE__,
8125                         "Failed to allocate symmetric crypto operation struct");
8126                 ret = TEST_FAILED;
8127                 goto on_err;
8128         }
8129
8130         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8131
8132         /* set crypto operation source mbuf */
8133         ut_params->op->sym->m_src = ut_params->ibuf;
8134         if (oop)
8135                 ut_params->op->sym->m_dst = ut_params->obuf;
8136
8137         /* Process crypto operation */
8138         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8139                 == NULL) {
8140                 printf("TestCase %s()-%d line %d failed %s: ",
8141                         __func__, i, __LINE__,
8142                         "failed to process sym crypto op");
8143                 ret = TEST_FAILED;
8144                 goto on_err;
8145         }
8146
8147         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8148                 printf("TestCase %s()-%d line %d failed %s: ",
8149                         __func__, i, __LINE__, "crypto op processing failed");
8150                 ret = TEST_FAILED;
8151                 goto on_err;
8152         }
8153
8154         /* Validate obuf */
8155         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8156                         uint8_t *);
8157         if (oop) {
8158                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8159                                 uint8_t *);
8160         }
8161         if (fragsz_oop)
8162                 fragsz = frag_size_oop;
8163         if (memcmp(ciphertext, output_vec, fragsz)) {
8164                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8165                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8166                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8167                 ret = TEST_FAILED;
8168                 goto on_err;
8169         }
8170
8171         buf = ut_params->op->sym->m_src->next;
8172         if (oop)
8173                 buf = ut_params->op->sym->m_dst->next;
8174
8175         unsigned int off = fragsz;
8176
8177         ecx = 0;
8178         while (buf) {
8179                 ciphertext = rte_pktmbuf_mtod(buf,
8180                                 uint8_t *);
8181                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8182                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8183                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8184                         rte_hexdump(stdout, "reference", output_vec + off,
8185                                         to_trn_tbl[ecx]);
8186                         ret = TEST_FAILED;
8187                         goto on_err;
8188                 }
8189                 off += to_trn_tbl[ecx++];
8190                 buf = buf->next;
8191         }
8192 on_err:
8193         rte_crypto_op_free(ut_params->op);
8194         ut_params->op = NULL;
8195
8196         if (ut_params->sec_session)
8197                 rte_security_session_destroy(ctx, ut_params->sec_session);
8198         ut_params->sec_session = NULL;
8199
8200         rte_pktmbuf_free(ut_params->ibuf);
8201         ut_params->ibuf = NULL;
8202         if (oop) {
8203                 rte_pktmbuf_free(ut_params->obuf);
8204                 ut_params->obuf = NULL;
8205         }
8206
8207         return ret;
8208 }
8209
8210 int
8211 test_pdcp_proto_cplane_encap(int i)
8212 {
8213         return test_pdcp_proto(
8214                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8215                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8216                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8217                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8218                 pdcp_test_params[i].cipher_key_len,
8219                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8220                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8221                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8222                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8223                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8224 }
8225
8226 int
8227 test_pdcp_proto_uplane_encap(int i)
8228 {
8229         return test_pdcp_proto(
8230                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8231                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8232                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8233                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8234                 pdcp_test_params[i].cipher_key_len,
8235                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8236                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8237                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8238                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8239                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8240 }
8241
8242 int
8243 test_pdcp_proto_uplane_encap_with_int(int i)
8244 {
8245         return test_pdcp_proto(
8246                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8247                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8248                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8249                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8250                 pdcp_test_params[i].cipher_key_len,
8251                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8252                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8253                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8254                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8255                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8256 }
8257
8258 int
8259 test_pdcp_proto_cplane_decap(int i)
8260 {
8261         return test_pdcp_proto(
8262                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8263                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8264                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8265                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8266                 pdcp_test_params[i].cipher_key_len,
8267                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8268                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8269                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8270                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8271                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8272 }
8273
8274 int
8275 test_pdcp_proto_uplane_decap(int i)
8276 {
8277         return test_pdcp_proto(
8278                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8279                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8280                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8281                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8282                 pdcp_test_params[i].cipher_key_len,
8283                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8284                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8285                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8286                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8287                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8288 }
8289
8290 int
8291 test_pdcp_proto_uplane_decap_with_int(int i)
8292 {
8293         return test_pdcp_proto(
8294                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8295                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8296                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8297                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8298                 pdcp_test_params[i].cipher_key_len,
8299                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8300                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8301                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8302                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8303                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8304 }
8305
8306 static int
8307 test_PDCP_PROTO_SGL_in_place_32B(void)
8308 {
8309         /* i can be used for running any PDCP case
8310          * In this case it is uplane 12-bit AES-SNOW DL encap
8311          */
8312         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8313         return test_pdcp_proto_SGL(i, IN_PLACE,
8314                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8315                         RTE_CRYPTO_AUTH_OP_GENERATE,
8316                         pdcp_test_data_in[i],
8317                         pdcp_test_data_in_len[i],
8318                         pdcp_test_data_out[i],
8319                         pdcp_test_data_in_len[i]+4,
8320                         32, 0);
8321 }
8322 static int
8323 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8324 {
8325         /* i can be used for running any PDCP case
8326          * In this case it is uplane 18-bit NULL-NULL DL encap
8327          */
8328         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8329         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8330                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8331                         RTE_CRYPTO_AUTH_OP_GENERATE,
8332                         pdcp_test_data_in[i],
8333                         pdcp_test_data_in_len[i],
8334                         pdcp_test_data_out[i],
8335                         pdcp_test_data_in_len[i]+4,
8336                         32, 128);
8337 }
8338 static int
8339 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8340 {
8341         /* i can be used for running any PDCP case
8342          * In this case it is uplane 18-bit AES DL encap
8343          */
8344         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8345                         + DOWNLINK;
8346         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8347                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8348                         RTE_CRYPTO_AUTH_OP_GENERATE,
8349                         pdcp_test_data_in[i],
8350                         pdcp_test_data_in_len[i],
8351                         pdcp_test_data_out[i],
8352                         pdcp_test_data_in_len[i],
8353                         32, 40);
8354 }
8355 static int
8356 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8357 {
8358         /* i can be used for running any PDCP case
8359          * In this case it is cplane 12-bit AES-ZUC DL encap
8360          */
8361         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8362         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8363                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8364                         RTE_CRYPTO_AUTH_OP_GENERATE,
8365                         pdcp_test_data_in[i],
8366                         pdcp_test_data_in_len[i],
8367                         pdcp_test_data_out[i],
8368                         pdcp_test_data_in_len[i]+4,
8369                         128, 32);
8370 }
8371
8372 static int
8373 test_PDCP_SDAP_PROTO_encap_all(void)
8374 {
8375         int i = 0, size = 0;
8376         int err, all_err = TEST_SUCCESS;
8377         const struct pdcp_sdap_test *cur_test;
8378
8379         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8380
8381         for (i = 0; i < size; i++) {
8382                 cur_test = &list_pdcp_sdap_tests[i];
8383                 err = test_pdcp_proto(
8384                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8385                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
8386                         cur_test->in_len, cur_test->data_out,
8387                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8388                         cur_test->param.cipher_alg, cur_test->cipher_key,
8389                         cur_test->param.cipher_key_len,
8390                         cur_test->param.auth_alg,
8391                         cur_test->auth_key, cur_test->param.auth_key_len,
8392                         cur_test->bearer, cur_test->param.domain,
8393                         cur_test->packet_direction, cur_test->sn_size,
8394                         cur_test->hfn,
8395                         cur_test->hfn_threshold, SDAP_ENABLED);
8396                 if (err) {
8397                         printf("\t%d) %s: Encapsulation failed\n",
8398                                         cur_test->test_idx,
8399                                         cur_test->param.name);
8400                         err = TEST_FAILED;
8401                 } else {
8402                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
8403                                         cur_test->param.name);
8404                         err = TEST_SUCCESS;
8405                 }
8406                 all_err += err;
8407         }
8408
8409         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8410
8411         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8412 }
8413
8414 static int
8415 test_PDCP_SDAP_PROTO_decap_all(void)
8416 {
8417         int i = 0, size = 0;
8418         int err, all_err = TEST_SUCCESS;
8419         const struct pdcp_sdap_test *cur_test;
8420
8421         size = ARRAY_SIZE(list_pdcp_sdap_tests);
8422
8423         for (i = 0; i < size; i++) {
8424                 cur_test = &list_pdcp_sdap_tests[i];
8425                 err = test_pdcp_proto(
8426                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
8427                         RTE_CRYPTO_AUTH_OP_VERIFY,
8428                         cur_test->data_out,
8429                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
8430                         cur_test->data_in, cur_test->in_len,
8431                         cur_test->param.cipher_alg,
8432                         cur_test->cipher_key, cur_test->param.cipher_key_len,
8433                         cur_test->param.auth_alg, cur_test->auth_key,
8434                         cur_test->param.auth_key_len, cur_test->bearer,
8435                         cur_test->param.domain, cur_test->packet_direction,
8436                         cur_test->sn_size, cur_test->hfn,
8437                         cur_test->hfn_threshold, SDAP_ENABLED);
8438                 if (err) {
8439                         printf("\t%d) %s: Decapsulation failed\n",
8440                                         cur_test->test_idx,
8441                                         cur_test->param.name);
8442                         err = TEST_FAILED;
8443                 } else {
8444                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
8445                                         cur_test->param.name);
8446                         err = TEST_SUCCESS;
8447                 }
8448                 all_err += err;
8449         }
8450
8451         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
8452
8453         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
8454 }
8455
8456 static int
8457 test_PDCP_PROTO_all(void)
8458 {
8459         struct crypto_testsuite_params *ts_params = &testsuite_params;
8460         struct crypto_unittest_params *ut_params = &unittest_params;
8461         struct rte_cryptodev_info dev_info;
8462         int status;
8463
8464         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8465         uint64_t feat_flags = dev_info.feature_flags;
8466
8467         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8468                 return -ENOTSUP;
8469
8470         /* Set action type */
8471         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8472                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8473                 gbl_action_type;
8474
8475         if (security_proto_supported(ut_params->type,
8476                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
8477                 return -ENOTSUP;
8478
8479         status = test_PDCP_PROTO_cplane_encap_all();
8480         status += test_PDCP_PROTO_cplane_decap_all();
8481         status += test_PDCP_PROTO_uplane_encap_all();
8482         status += test_PDCP_PROTO_uplane_decap_all();
8483         status += test_PDCP_PROTO_SGL_in_place_32B();
8484         status += test_PDCP_PROTO_SGL_oop_32B_128B();
8485         status += test_PDCP_PROTO_SGL_oop_32B_40B();
8486         status += test_PDCP_PROTO_SGL_oop_128B_32B();
8487         status += test_PDCP_SDAP_PROTO_encap_all();
8488         status += test_PDCP_SDAP_PROTO_decap_all();
8489
8490         if (status)
8491                 return TEST_FAILED;
8492         else
8493                 return TEST_SUCCESS;
8494 }
8495
8496 static int
8497 test_docsis_proto_uplink(int i, struct docsis_test_data *d_td)
8498 {
8499         struct crypto_testsuite_params *ts_params = &testsuite_params;
8500         struct crypto_unittest_params *ut_params = &unittest_params;
8501         uint8_t *plaintext, *ciphertext;
8502         uint8_t *iv_ptr;
8503         int32_t cipher_len, crc_len;
8504         uint32_t crc_data_len;
8505         int ret = TEST_SUCCESS;
8506
8507         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8508                                         rte_cryptodev_get_sec_ctx(
8509                                                 ts_params->valid_devs[0]);
8510
8511         /* Verify the capabilities */
8512         struct rte_security_capability_idx sec_cap_idx;
8513         const struct rte_security_capability *sec_cap;
8514         const struct rte_cryptodev_capabilities *crypto_cap;
8515         const struct rte_cryptodev_symmetric_capability *sym_cap;
8516         int j = 0;
8517
8518         sec_cap_idx.action = ut_params->type;
8519         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8520         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
8521
8522         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8523         if (sec_cap == NULL)
8524                 return -ENOTSUP;
8525
8526         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8527                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8528                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8529                                 crypto_cap->sym.xform_type ==
8530                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8531                                 crypto_cap->sym.cipher.algo ==
8532                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8533                         sym_cap = &crypto_cap->sym;
8534                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8535                                                 d_td->key.len,
8536                                                 d_td->iv.len) == 0)
8537                                 break;
8538                 }
8539         }
8540
8541         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8542                 return -ENOTSUP;
8543
8544         /* Setup source mbuf payload */
8545         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8546         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8547                         rte_pktmbuf_tailroom(ut_params->ibuf));
8548
8549         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8550                         d_td->ciphertext.len);
8551
8552         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
8553
8554         /* Setup cipher session parameters */
8555         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8556         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8557         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
8558         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8559         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8560         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8561         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8562         ut_params->cipher_xform.next = NULL;
8563
8564         /* Setup DOCSIS session parameters */
8565         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
8566
8567         struct rte_security_session_conf sess_conf = {
8568                 .action_type = ut_params->type,
8569                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8570                 .docsis = ut_params->docsis_xform,
8571                 .crypto_xform = &ut_params->cipher_xform,
8572         };
8573
8574         /* Create security session */
8575         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8576                                         ts_params->session_mpool,
8577                                         ts_params->session_priv_mpool);
8578
8579         if (!ut_params->sec_session) {
8580                 printf("TestCase %s(%d) line %d: %s\n",
8581                         __func__, i, __LINE__, "failed to allocate session");
8582                 ret = TEST_FAILED;
8583                 goto on_err;
8584         }
8585
8586         /* Generate crypto op data structure */
8587         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8588                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8589         if (!ut_params->op) {
8590                 printf("TestCase %s(%d) line %d: %s\n",
8591                         __func__, i, __LINE__,
8592                         "failed to allocate symmetric crypto operation");
8593                 ret = TEST_FAILED;
8594                 goto on_err;
8595         }
8596
8597         /* Setup CRC operation parameters */
8598         crc_len = d_td->ciphertext.no_crc == false ?
8599                         (d_td->ciphertext.len -
8600                                 d_td->ciphertext.crc_offset -
8601                                 RTE_ETHER_CRC_LEN) :
8602                         0;
8603         crc_len = crc_len > 0 ? crc_len : 0;
8604         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
8605         ut_params->op->sym->auth.data.length = crc_len;
8606         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
8607
8608         /* Setup cipher operation parameters */
8609         cipher_len = d_td->ciphertext.no_cipher == false ?
8610                         (d_td->ciphertext.len -
8611                                 d_td->ciphertext.cipher_offset) :
8612                         0;
8613         cipher_len = cipher_len > 0 ? cipher_len : 0;
8614         ut_params->op->sym->cipher.data.length = cipher_len;
8615         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
8616
8617         /* Setup cipher IV */
8618         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8619         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8620
8621         /* Attach session to operation */
8622         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8623
8624         /* Set crypto operation mbufs */
8625         ut_params->op->sym->m_src = ut_params->ibuf;
8626         ut_params->op->sym->m_dst = NULL;
8627
8628         /* Process crypto operation */
8629         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8630                         NULL) {
8631                 printf("TestCase %s(%d) line %d: %s\n",
8632                         __func__, i, __LINE__,
8633                         "failed to process security crypto op");
8634                 ret = TEST_FAILED;
8635                 goto on_err;
8636         }
8637
8638         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8639                 printf("TestCase %s(%d) line %d: %s\n",
8640                         __func__, i, __LINE__, "crypto op processing failed");
8641                 ret = TEST_FAILED;
8642                 goto on_err;
8643         }
8644
8645         /* Validate plaintext */
8646         plaintext = ciphertext;
8647
8648         if (memcmp(plaintext, d_td->plaintext.data,
8649                         d_td->plaintext.len - crc_data_len)) {
8650                 printf("TestCase %s(%d) line %d: %s\n",
8651                         __func__, i, __LINE__, "plaintext not as expected\n");
8652                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
8653                                 d_td->plaintext.len);
8654                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
8655                 ret = TEST_FAILED;
8656                 goto on_err;
8657         }
8658
8659 on_err:
8660         rte_crypto_op_free(ut_params->op);
8661         ut_params->op = NULL;
8662
8663         if (ut_params->sec_session)
8664                 rte_security_session_destroy(ctx, ut_params->sec_session);
8665         ut_params->sec_session = NULL;
8666
8667         rte_pktmbuf_free(ut_params->ibuf);
8668         ut_params->ibuf = NULL;
8669
8670         return ret;
8671 }
8672
8673 static int
8674 test_docsis_proto_downlink(int i, struct docsis_test_data *d_td)
8675 {
8676         struct crypto_testsuite_params *ts_params = &testsuite_params;
8677         struct crypto_unittest_params *ut_params = &unittest_params;
8678         uint8_t *plaintext, *ciphertext;
8679         uint8_t *iv_ptr;
8680         int32_t cipher_len, crc_len;
8681         int ret = TEST_SUCCESS;
8682
8683         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8684                                         rte_cryptodev_get_sec_ctx(
8685                                                 ts_params->valid_devs[0]);
8686
8687         /* Verify the capabilities */
8688         struct rte_security_capability_idx sec_cap_idx;
8689         const struct rte_security_capability *sec_cap;
8690         const struct rte_cryptodev_capabilities *crypto_cap;
8691         const struct rte_cryptodev_symmetric_capability *sym_cap;
8692         int j = 0;
8693
8694         sec_cap_idx.action = ut_params->type;
8695         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
8696         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8697
8698         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
8699         if (sec_cap == NULL)
8700                 return -ENOTSUP;
8701
8702         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
8703                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
8704                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
8705                                 crypto_cap->sym.xform_type ==
8706                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
8707                                 crypto_cap->sym.cipher.algo ==
8708                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
8709                         sym_cap = &crypto_cap->sym;
8710                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
8711                                                 d_td->key.len,
8712                                                 d_td->iv.len) == 0)
8713                                 break;
8714                 }
8715         }
8716
8717         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
8718                 return -ENOTSUP;
8719
8720         /* Setup source mbuf payload */
8721         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8722         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8723                         rte_pktmbuf_tailroom(ut_params->ibuf));
8724
8725         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8726                         d_td->plaintext.len);
8727
8728         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
8729
8730         /* Setup cipher session parameters */
8731         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8732         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
8733         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
8734         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
8735         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
8736         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
8737         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8738         ut_params->cipher_xform.next = NULL;
8739
8740         /* Setup DOCSIS session parameters */
8741         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
8742
8743         struct rte_security_session_conf sess_conf = {
8744                 .action_type = ut_params->type,
8745                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
8746                 .docsis = ut_params->docsis_xform,
8747                 .crypto_xform = &ut_params->cipher_xform,
8748         };
8749
8750         /* Create security session */
8751         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
8752                                         ts_params->session_mpool,
8753                                         ts_params->session_priv_mpool);
8754
8755         if (!ut_params->sec_session) {
8756                 printf("TestCase %s(%d) line %d: %s\n",
8757                         __func__, i, __LINE__, "failed to allocate session");
8758                 ret = TEST_FAILED;
8759                 goto on_err;
8760         }
8761
8762         /* Generate crypto op data structure */
8763         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8764                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8765         if (!ut_params->op) {
8766                 printf("TestCase %s(%d) line %d: %s\n",
8767                         __func__, i, __LINE__,
8768                         "failed to allocate security crypto operation");
8769                 ret = TEST_FAILED;
8770                 goto on_err;
8771         }
8772
8773         /* Setup CRC operation parameters */
8774         crc_len = d_td->plaintext.no_crc == false ?
8775                         (d_td->plaintext.len -
8776                                 d_td->plaintext.crc_offset -
8777                                 RTE_ETHER_CRC_LEN) :
8778                         0;
8779         crc_len = crc_len > 0 ? crc_len : 0;
8780         ut_params->op->sym->auth.data.length = crc_len;
8781         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
8782
8783         /* Setup cipher operation parameters */
8784         cipher_len = d_td->plaintext.no_cipher == false ?
8785                         (d_td->plaintext.len -
8786                                 d_td->plaintext.cipher_offset) :
8787                         0;
8788         cipher_len = cipher_len > 0 ? cipher_len : 0;
8789         ut_params->op->sym->cipher.data.length = cipher_len;
8790         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
8791
8792         /* Setup cipher IV */
8793         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
8794         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
8795
8796         /* Attach session to operation */
8797         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8798
8799         /* Set crypto operation mbufs */
8800         ut_params->op->sym->m_src = ut_params->ibuf;
8801         ut_params->op->sym->m_dst = NULL;
8802
8803         /* Process crypto operation */
8804         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
8805                         NULL) {
8806                 printf("TestCase %s(%d) line %d: %s\n",
8807                         __func__, i, __LINE__,
8808                         "failed to process security crypto op");
8809                 ret = TEST_FAILED;
8810                 goto on_err;
8811         }
8812
8813         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8814                 printf("TestCase %s(%d) line %d: %s\n",
8815                         __func__, i, __LINE__, "crypto op processing failed");
8816                 ret = TEST_FAILED;
8817                 goto on_err;
8818         }
8819
8820         /* Validate ciphertext */
8821         ciphertext = plaintext;
8822
8823         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
8824                 printf("TestCase %s(%d) line %d: %s\n",
8825                         __func__, i, __LINE__, "ciphertext not as expected\n");
8826                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
8827                                 d_td->ciphertext.len);
8828                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
8829                 ret = TEST_FAILED;
8830                 goto on_err;
8831         }
8832
8833 on_err:
8834         rte_crypto_op_free(ut_params->op);
8835         ut_params->op = NULL;
8836
8837         if (ut_params->sec_session)
8838                 rte_security_session_destroy(ctx, ut_params->sec_session);
8839         ut_params->sec_session = NULL;
8840
8841         rte_pktmbuf_free(ut_params->ibuf);
8842         ut_params->ibuf = NULL;
8843
8844         return ret;
8845 }
8846
8847 #define TEST_DOCSIS_COUNT(func) do {                    \
8848         int ret = func;                                 \
8849         if (ret == TEST_SUCCESS)  {                     \
8850                 printf("\t%2d)", n++);                  \
8851                 printf("+++++ PASSED:" #func"\n");      \
8852                 p++;                                    \
8853         } else if (ret == -ENOTSUP) {                   \
8854                 printf("\t%2d)", n++);                  \
8855                 printf("~~~~~ UNSUPP:" #func"\n");      \
8856                 u++;                                    \
8857         } else {                                        \
8858                 printf("\t%2d)", n++);                  \
8859                 printf("----- FAILED:" #func"\n");      \
8860                 f++;                                    \
8861         }                                               \
8862 } while (0)
8863
8864 static int
8865 test_DOCSIS_PROTO_uplink_all(void)
8866 {
8867         int p = 0, u = 0, f = 0, n = 0;
8868
8869         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
8870         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
8871         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(3, &docsis_test_case_3));
8872         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(4, &docsis_test_case_4));
8873         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(5, &docsis_test_case_5));
8874         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(6, &docsis_test_case_6));
8875         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(7, &docsis_test_case_7));
8876         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(8, &docsis_test_case_8));
8877         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(9, &docsis_test_case_9));
8878         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(10, &docsis_test_case_10));
8879         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(11, &docsis_test_case_11));
8880         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(12, &docsis_test_case_12));
8881         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(13, &docsis_test_case_13));
8882         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(14, &docsis_test_case_14));
8883         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(15, &docsis_test_case_15));
8884         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(16, &docsis_test_case_16));
8885         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(17, &docsis_test_case_17));
8886         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(18, &docsis_test_case_18));
8887         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(19, &docsis_test_case_19));
8888         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(20, &docsis_test_case_20));
8889         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(21, &docsis_test_case_21));
8890         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(22, &docsis_test_case_22));
8891         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(23, &docsis_test_case_23));
8892         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(24, &docsis_test_case_24));
8893         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(25, &docsis_test_case_25));
8894         TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
8895
8896         if (f)
8897                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8898                         __func__, p, n, u);
8899
8900         return f;
8901 };
8902
8903 static int
8904 test_DOCSIS_PROTO_downlink_all(void)
8905 {
8906         int p = 0, u = 0, f = 0, n = 0;
8907
8908         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
8909         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
8910         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(3, &docsis_test_case_3));
8911         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(4, &docsis_test_case_4));
8912         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(5, &docsis_test_case_5));
8913         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(6, &docsis_test_case_6));
8914         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(7, &docsis_test_case_7));
8915         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(8, &docsis_test_case_8));
8916         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(9, &docsis_test_case_9));
8917         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(10, &docsis_test_case_10));
8918         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(11, &docsis_test_case_11));
8919         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(12, &docsis_test_case_12));
8920         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(13, &docsis_test_case_13));
8921         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(14, &docsis_test_case_14));
8922         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(15, &docsis_test_case_15));
8923         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(16, &docsis_test_case_16));
8924         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(17, &docsis_test_case_17));
8925         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(18, &docsis_test_case_18));
8926         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(19, &docsis_test_case_19));
8927         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(20, &docsis_test_case_20));
8928         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(21, &docsis_test_case_21));
8929         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(22, &docsis_test_case_22));
8930         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(23, &docsis_test_case_23));
8931         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(24, &docsis_test_case_24));
8932         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(25, &docsis_test_case_25));
8933         TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
8934
8935         if (f)
8936                 printf("## %s: %d passed out of %d (%d unsupported)\n",
8937                         __func__, p, n, u);
8938
8939         return f;
8940 };
8941
8942 static int
8943 test_DOCSIS_PROTO_all(void)
8944 {
8945         struct crypto_testsuite_params *ts_params = &testsuite_params;
8946         struct crypto_unittest_params *ut_params = &unittest_params;
8947         struct rte_cryptodev_info dev_info;
8948         int status;
8949
8950         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8951         uint64_t feat_flags = dev_info.feature_flags;
8952
8953         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
8954                 return -ENOTSUP;
8955
8956         /* Set action type */
8957         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
8958                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
8959                 gbl_action_type;
8960
8961         if (security_proto_supported(ut_params->type,
8962                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
8963                 return -ENOTSUP;
8964
8965         status = test_DOCSIS_PROTO_uplink_all();
8966         status += test_DOCSIS_PROTO_downlink_all();
8967
8968         if (status)
8969                 return TEST_FAILED;
8970         else
8971                 return TEST_SUCCESS;
8972 }
8973 #endif
8974
8975 static int
8976 test_AES_GCM_authenticated_encryption_test_case_1(void)
8977 {
8978         return test_authenticated_encryption(&gcm_test_case_1);
8979 }
8980
8981 static int
8982 test_AES_GCM_authenticated_encryption_test_case_2(void)
8983 {
8984         return test_authenticated_encryption(&gcm_test_case_2);
8985 }
8986
8987 static int
8988 test_AES_GCM_authenticated_encryption_test_case_3(void)
8989 {
8990         return test_authenticated_encryption(&gcm_test_case_3);
8991 }
8992
8993 static int
8994 test_AES_GCM_authenticated_encryption_test_case_4(void)
8995 {
8996         return test_authenticated_encryption(&gcm_test_case_4);
8997 }
8998
8999 static int
9000 test_AES_GCM_authenticated_encryption_test_case_5(void)
9001 {
9002         return test_authenticated_encryption(&gcm_test_case_5);
9003 }
9004
9005 static int
9006 test_AES_GCM_authenticated_encryption_test_case_6(void)
9007 {
9008         return test_authenticated_encryption(&gcm_test_case_6);
9009 }
9010
9011 static int
9012 test_AES_GCM_authenticated_encryption_test_case_7(void)
9013 {
9014         return test_authenticated_encryption(&gcm_test_case_7);
9015 }
9016
9017 static int
9018 test_AES_GCM_authenticated_encryption_test_case_8(void)
9019 {
9020         return test_authenticated_encryption(&gcm_test_case_8);
9021 }
9022
9023 static int
9024 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
9025 {
9026         return test_authenticated_encryption(&gcm_J0_test_case_1);
9027 }
9028
9029 static int
9030 test_AES_GCM_auth_encryption_test_case_192_1(void)
9031 {
9032         return test_authenticated_encryption(&gcm_test_case_192_1);
9033 }
9034
9035 static int
9036 test_AES_GCM_auth_encryption_test_case_192_2(void)
9037 {
9038         return test_authenticated_encryption(&gcm_test_case_192_2);
9039 }
9040
9041 static int
9042 test_AES_GCM_auth_encryption_test_case_192_3(void)
9043 {
9044         return test_authenticated_encryption(&gcm_test_case_192_3);
9045 }
9046
9047 static int
9048 test_AES_GCM_auth_encryption_test_case_192_4(void)
9049 {
9050         return test_authenticated_encryption(&gcm_test_case_192_4);
9051 }
9052
9053 static int
9054 test_AES_GCM_auth_encryption_test_case_192_5(void)
9055 {
9056         return test_authenticated_encryption(&gcm_test_case_192_5);
9057 }
9058
9059 static int
9060 test_AES_GCM_auth_encryption_test_case_192_6(void)
9061 {
9062         return test_authenticated_encryption(&gcm_test_case_192_6);
9063 }
9064
9065 static int
9066 test_AES_GCM_auth_encryption_test_case_192_7(void)
9067 {
9068         return test_authenticated_encryption(&gcm_test_case_192_7);
9069 }
9070
9071 static int
9072 test_AES_GCM_auth_encryption_test_case_256_1(void)
9073 {
9074         return test_authenticated_encryption(&gcm_test_case_256_1);
9075 }
9076
9077 static int
9078 test_AES_GCM_auth_encryption_test_case_256_2(void)
9079 {
9080         return test_authenticated_encryption(&gcm_test_case_256_2);
9081 }
9082
9083 static int
9084 test_AES_GCM_auth_encryption_test_case_256_3(void)
9085 {
9086         return test_authenticated_encryption(&gcm_test_case_256_3);
9087 }
9088
9089 static int
9090 test_AES_GCM_auth_encryption_test_case_256_4(void)
9091 {
9092         return test_authenticated_encryption(&gcm_test_case_256_4);
9093 }
9094
9095 static int
9096 test_AES_GCM_auth_encryption_test_case_256_5(void)
9097 {
9098         return test_authenticated_encryption(&gcm_test_case_256_5);
9099 }
9100
9101 static int
9102 test_AES_GCM_auth_encryption_test_case_256_6(void)
9103 {
9104         return test_authenticated_encryption(&gcm_test_case_256_6);
9105 }
9106
9107 static int
9108 test_AES_GCM_auth_encryption_test_case_256_7(void)
9109 {
9110         return test_authenticated_encryption(&gcm_test_case_256_7);
9111 }
9112
9113 static int
9114 test_AES_GCM_auth_encryption_test_case_aad_1(void)
9115 {
9116         return test_authenticated_encryption(&gcm_test_case_aad_1);
9117 }
9118
9119 static int
9120 test_AES_GCM_auth_encryption_test_case_aad_2(void)
9121 {
9122         return test_authenticated_encryption(&gcm_test_case_aad_2);
9123 }
9124
9125 static int
9126 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
9127 {
9128         struct aead_test_data tdata;
9129         int res;
9130
9131         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9132         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9133         tdata.iv.data[0] += 1;
9134         res = test_authenticated_encryption(&tdata);
9135         if (res == -ENOTSUP)
9136                 return res;
9137         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9138         return TEST_SUCCESS;
9139 }
9140
9141 static int
9142 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
9143 {
9144         struct aead_test_data tdata;
9145         int res;
9146
9147         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9148         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9149         tdata.plaintext.data[0] += 1;
9150         res = test_authenticated_encryption(&tdata);
9151         if (res == -ENOTSUP)
9152                 return res;
9153         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9154         return TEST_SUCCESS;
9155 }
9156
9157 static int
9158 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
9159 {
9160         struct aead_test_data tdata;
9161         int res;
9162
9163         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9164         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9165         tdata.ciphertext.data[0] += 1;
9166         res = test_authenticated_encryption(&tdata);
9167         if (res == -ENOTSUP)
9168                 return res;
9169         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9170         return TEST_SUCCESS;
9171 }
9172
9173 static int
9174 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
9175 {
9176         struct aead_test_data tdata;
9177         int res;
9178
9179         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9180         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9181         tdata.aad.len += 1;
9182         res = test_authenticated_encryption(&tdata);
9183         if (res == -ENOTSUP)
9184                 return res;
9185         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9186         return TEST_SUCCESS;
9187 }
9188
9189 static int
9190 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
9191 {
9192         struct aead_test_data tdata;
9193         uint8_t aad[gcm_test_case_7.aad.len];
9194         int res;
9195
9196         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9197         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9198         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9199         aad[0] += 1;
9200         tdata.aad.data = aad;
9201         res = test_authenticated_encryption(&tdata);
9202         if (res == -ENOTSUP)
9203                 return res;
9204         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9205         return TEST_SUCCESS;
9206 }
9207
9208 static int
9209 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
9210 {
9211         struct aead_test_data tdata;
9212         int res;
9213
9214         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9215         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9216         tdata.auth_tag.data[0] += 1;
9217         res = test_authenticated_encryption(&tdata);
9218         if (res == -ENOTSUP)
9219                 return res;
9220         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
9221         return TEST_SUCCESS;
9222 }
9223
9224 static int
9225 test_authenticated_decryption(const struct aead_test_data *tdata)
9226 {
9227         struct crypto_testsuite_params *ts_params = &testsuite_params;
9228         struct crypto_unittest_params *ut_params = &unittest_params;
9229
9230         int retval;
9231         uint8_t *plaintext;
9232         uint32_t i;
9233         struct rte_cryptodev_info dev_info;
9234
9235         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9236         uint64_t feat_flags = dev_info.feature_flags;
9237
9238         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9239                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9240                 printf("Device doesn't support RAW data-path APIs.\n");
9241                 return -ENOTSUP;
9242         }
9243
9244         /* Verify the capabilities */
9245         struct rte_cryptodev_sym_capability_idx cap_idx;
9246         const struct rte_cryptodev_symmetric_capability *capability;
9247         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9248         cap_idx.algo.aead = tdata->algo;
9249         capability = rte_cryptodev_sym_capability_get(
9250                         ts_params->valid_devs[0], &cap_idx);
9251         if (capability == NULL)
9252                 return -ENOTSUP;
9253         if (rte_cryptodev_sym_capability_check_aead(
9254                         capability, tdata->key.len, tdata->auth_tag.len,
9255                         tdata->aad.len, tdata->iv.len))
9256                 return -ENOTSUP;
9257
9258         /* Create AEAD session */
9259         retval = create_aead_session(ts_params->valid_devs[0],
9260                         tdata->algo,
9261                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9262                         tdata->key.data, tdata->key.len,
9263                         tdata->aad.len, tdata->auth_tag.len,
9264                         tdata->iv.len);
9265         if (retval < 0)
9266                 return retval;
9267
9268         /* alloc mbuf and set payload */
9269         if (tdata->aad.len > MBUF_SIZE) {
9270                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
9271                 /* Populate full size of add data */
9272                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
9273                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
9274         } else
9275                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9276
9277         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9278                         rte_pktmbuf_tailroom(ut_params->ibuf));
9279
9280         /* Create AEAD operation */
9281         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9282         if (retval < 0)
9283                 return retval;
9284
9285         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9286
9287         ut_params->op->sym->m_src = ut_params->ibuf;
9288
9289         /* Process crypto operation */
9290         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9291                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
9292         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9293                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9294                                 ut_params->op, 0, 0, 0, 0);
9295         else
9296                 TEST_ASSERT_NOT_NULL(
9297                         process_crypto_request(ts_params->valid_devs[0],
9298                         ut_params->op), "failed to process sym crypto op");
9299
9300         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9301                         "crypto op processing failed");
9302
9303         if (ut_params->op->sym->m_dst)
9304                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
9305                                 uint8_t *);
9306         else
9307                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
9308                                 uint8_t *,
9309                                 ut_params->op->sym->cipher.data.offset);
9310
9311         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9312
9313         /* Validate obuf */
9314         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9315                         plaintext,
9316                         tdata->plaintext.data,
9317                         tdata->plaintext.len,
9318                         "Plaintext data not as expected");
9319
9320         TEST_ASSERT_EQUAL(ut_params->op->status,
9321                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9322                         "Authentication failed");
9323
9324         return 0;
9325 }
9326
9327 static int
9328 test_AES_GCM_authenticated_decryption_test_case_1(void)
9329 {
9330         return test_authenticated_decryption(&gcm_test_case_1);
9331 }
9332
9333 static int
9334 test_AES_GCM_authenticated_decryption_test_case_2(void)
9335 {
9336         return test_authenticated_decryption(&gcm_test_case_2);
9337 }
9338
9339 static int
9340 test_AES_GCM_authenticated_decryption_test_case_3(void)
9341 {
9342         return test_authenticated_decryption(&gcm_test_case_3);
9343 }
9344
9345 static int
9346 test_AES_GCM_authenticated_decryption_test_case_4(void)
9347 {
9348         return test_authenticated_decryption(&gcm_test_case_4);
9349 }
9350
9351 static int
9352 test_AES_GCM_authenticated_decryption_test_case_5(void)
9353 {
9354         return test_authenticated_decryption(&gcm_test_case_5);
9355 }
9356
9357 static int
9358 test_AES_GCM_authenticated_decryption_test_case_6(void)
9359 {
9360         return test_authenticated_decryption(&gcm_test_case_6);
9361 }
9362
9363 static int
9364 test_AES_GCM_authenticated_decryption_test_case_7(void)
9365 {
9366         return test_authenticated_decryption(&gcm_test_case_7);
9367 }
9368
9369 static int
9370 test_AES_GCM_authenticated_decryption_test_case_8(void)
9371 {
9372         return test_authenticated_decryption(&gcm_test_case_8);
9373 }
9374
9375 static int
9376 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
9377 {
9378         return test_authenticated_decryption(&gcm_J0_test_case_1);
9379 }
9380
9381 static int
9382 test_AES_GCM_auth_decryption_test_case_192_1(void)
9383 {
9384         return test_authenticated_decryption(&gcm_test_case_192_1);
9385 }
9386
9387 static int
9388 test_AES_GCM_auth_decryption_test_case_192_2(void)
9389 {
9390         return test_authenticated_decryption(&gcm_test_case_192_2);
9391 }
9392
9393 static int
9394 test_AES_GCM_auth_decryption_test_case_192_3(void)
9395 {
9396         return test_authenticated_decryption(&gcm_test_case_192_3);
9397 }
9398
9399 static int
9400 test_AES_GCM_auth_decryption_test_case_192_4(void)
9401 {
9402         return test_authenticated_decryption(&gcm_test_case_192_4);
9403 }
9404
9405 static int
9406 test_AES_GCM_auth_decryption_test_case_192_5(void)
9407 {
9408         return test_authenticated_decryption(&gcm_test_case_192_5);
9409 }
9410
9411 static int
9412 test_AES_GCM_auth_decryption_test_case_192_6(void)
9413 {
9414         return test_authenticated_decryption(&gcm_test_case_192_6);
9415 }
9416
9417 static int
9418 test_AES_GCM_auth_decryption_test_case_192_7(void)
9419 {
9420         return test_authenticated_decryption(&gcm_test_case_192_7);
9421 }
9422
9423 static int
9424 test_AES_GCM_auth_decryption_test_case_256_1(void)
9425 {
9426         return test_authenticated_decryption(&gcm_test_case_256_1);
9427 }
9428
9429 static int
9430 test_AES_GCM_auth_decryption_test_case_256_2(void)
9431 {
9432         return test_authenticated_decryption(&gcm_test_case_256_2);
9433 }
9434
9435 static int
9436 test_AES_GCM_auth_decryption_test_case_256_3(void)
9437 {
9438         return test_authenticated_decryption(&gcm_test_case_256_3);
9439 }
9440
9441 static int
9442 test_AES_GCM_auth_decryption_test_case_256_4(void)
9443 {
9444         return test_authenticated_decryption(&gcm_test_case_256_4);
9445 }
9446
9447 static int
9448 test_AES_GCM_auth_decryption_test_case_256_5(void)
9449 {
9450         return test_authenticated_decryption(&gcm_test_case_256_5);
9451 }
9452
9453 static int
9454 test_AES_GCM_auth_decryption_test_case_256_6(void)
9455 {
9456         return test_authenticated_decryption(&gcm_test_case_256_6);
9457 }
9458
9459 static int
9460 test_AES_GCM_auth_decryption_test_case_256_7(void)
9461 {
9462         return test_authenticated_decryption(&gcm_test_case_256_7);
9463 }
9464
9465 static int
9466 test_AES_GCM_auth_decryption_test_case_aad_1(void)
9467 {
9468         return test_authenticated_decryption(&gcm_test_case_aad_1);
9469 }
9470
9471 static int
9472 test_AES_GCM_auth_decryption_test_case_aad_2(void)
9473 {
9474         return test_authenticated_decryption(&gcm_test_case_aad_2);
9475 }
9476
9477 static int
9478 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
9479 {
9480         struct aead_test_data tdata;
9481         int res;
9482
9483         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9484         tdata.iv.data[0] += 1;
9485         res = test_authenticated_decryption(&tdata);
9486         if (res == -ENOTSUP)
9487                 return res;
9488         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9489         return TEST_SUCCESS;
9490 }
9491
9492 static int
9493 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
9494 {
9495         struct aead_test_data tdata;
9496         int res;
9497
9498         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
9499         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9500         tdata.plaintext.data[0] += 1;
9501         res = test_authenticated_decryption(&tdata);
9502         if (res == -ENOTSUP)
9503                 return res;
9504         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9505         return TEST_SUCCESS;
9506 }
9507
9508 static int
9509 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
9510 {
9511         struct aead_test_data tdata;
9512         int res;
9513
9514         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9515         tdata.ciphertext.data[0] += 1;
9516         res = test_authenticated_decryption(&tdata);
9517         if (res == -ENOTSUP)
9518                 return res;
9519         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9520         return TEST_SUCCESS;
9521 }
9522
9523 static int
9524 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
9525 {
9526         struct aead_test_data tdata;
9527         int res;
9528
9529         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9530         tdata.aad.len += 1;
9531         res = test_authenticated_decryption(&tdata);
9532         if (res == -ENOTSUP)
9533                 return res;
9534         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9535         return TEST_SUCCESS;
9536 }
9537
9538 static int
9539 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
9540 {
9541         struct aead_test_data tdata;
9542         uint8_t aad[gcm_test_case_7.aad.len];
9543         int res;
9544
9545         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9546         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
9547         aad[0] += 1;
9548         tdata.aad.data = aad;
9549         res = test_authenticated_decryption(&tdata);
9550         if (res == -ENOTSUP)
9551                 return res;
9552         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
9553         return TEST_SUCCESS;
9554 }
9555
9556 static int
9557 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
9558 {
9559         struct aead_test_data tdata;
9560         int res;
9561
9562         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
9563         tdata.auth_tag.data[0] += 1;
9564         res = test_authenticated_decryption(&tdata);
9565         if (res == -ENOTSUP)
9566                 return res;
9567         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
9568         return TEST_SUCCESS;
9569 }
9570
9571 static int
9572 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
9573 {
9574         struct crypto_testsuite_params *ts_params = &testsuite_params;
9575         struct crypto_unittest_params *ut_params = &unittest_params;
9576
9577         int retval;
9578         uint8_t *ciphertext, *auth_tag;
9579         uint16_t plaintext_pad_len;
9580
9581         /* Verify the capabilities */
9582         struct rte_cryptodev_sym_capability_idx cap_idx;
9583         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9584         cap_idx.algo.aead = tdata->algo;
9585         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9586                         &cap_idx) == NULL)
9587                 return -ENOTSUP;
9588
9589         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9590                 return -ENOTSUP;
9591
9592         /* not supported with CPU crypto */
9593         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9594                 return -ENOTSUP;
9595
9596         /* Create AEAD session */
9597         retval = create_aead_session(ts_params->valid_devs[0],
9598                         tdata->algo,
9599                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9600                         tdata->key.data, tdata->key.len,
9601                         tdata->aad.len, tdata->auth_tag.len,
9602                         tdata->iv.len);
9603         if (retval < 0)
9604                 return retval;
9605
9606         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9607         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9608
9609         /* clear mbuf payload */
9610         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9611                         rte_pktmbuf_tailroom(ut_params->ibuf));
9612         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9613                         rte_pktmbuf_tailroom(ut_params->obuf));
9614
9615         /* Create AEAD operation */
9616         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9617         if (retval < 0)
9618                 return retval;
9619
9620         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9621
9622         ut_params->op->sym->m_src = ut_params->ibuf;
9623         ut_params->op->sym->m_dst = ut_params->obuf;
9624
9625         /* Process crypto operation */
9626         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9627                         ut_params->op), "failed to process sym crypto op");
9628
9629         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9630                         "crypto op processing failed");
9631
9632         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9633
9634         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9635                         ut_params->op->sym->cipher.data.offset);
9636         auth_tag = ciphertext + plaintext_pad_len;
9637
9638         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9639         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9640
9641         /* Validate obuf */
9642         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9643                         ciphertext,
9644                         tdata->ciphertext.data,
9645                         tdata->ciphertext.len,
9646                         "Ciphertext data not as expected");
9647
9648         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9649                         auth_tag,
9650                         tdata->auth_tag.data,
9651                         tdata->auth_tag.len,
9652                         "Generated auth tag not as expected");
9653
9654         return 0;
9655
9656 }
9657
9658 static int
9659 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
9660 {
9661         return test_authenticated_encryption_oop(&gcm_test_case_5);
9662 }
9663
9664 static int
9665 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
9666 {
9667         struct crypto_testsuite_params *ts_params = &testsuite_params;
9668         struct crypto_unittest_params *ut_params = &unittest_params;
9669
9670         int retval;
9671         uint8_t *plaintext;
9672
9673         /* Verify the capabilities */
9674         struct rte_cryptodev_sym_capability_idx cap_idx;
9675         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9676         cap_idx.algo.aead = tdata->algo;
9677         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9678                         &cap_idx) == NULL)
9679                 return -ENOTSUP;
9680
9681         /* not supported with CPU crypto and raw data-path APIs*/
9682         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
9683                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
9684                 return -ENOTSUP;
9685
9686         /* Create AEAD session */
9687         retval = create_aead_session(ts_params->valid_devs[0],
9688                         tdata->algo,
9689                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9690                         tdata->key.data, tdata->key.len,
9691                         tdata->aad.len, tdata->auth_tag.len,
9692                         tdata->iv.len);
9693         if (retval < 0)
9694                 return retval;
9695
9696         /* alloc mbuf and set payload */
9697         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9698         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9699
9700         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9701                         rte_pktmbuf_tailroom(ut_params->ibuf));
9702         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
9703                         rte_pktmbuf_tailroom(ut_params->obuf));
9704
9705         /* Create AEAD operation */
9706         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9707         if (retval < 0)
9708                 return retval;
9709
9710         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
9711
9712         ut_params->op->sym->m_src = ut_params->ibuf;
9713         ut_params->op->sym->m_dst = ut_params->obuf;
9714
9715         /* Process crypto operation */
9716         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9717                         ut_params->op), "failed to process sym crypto op");
9718
9719         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9720                         "crypto op processing failed");
9721
9722         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
9723                         ut_params->op->sym->cipher.data.offset);
9724
9725         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9726
9727         /* Validate obuf */
9728         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9729                         plaintext,
9730                         tdata->plaintext.data,
9731                         tdata->plaintext.len,
9732                         "Plaintext data not as expected");
9733
9734         TEST_ASSERT_EQUAL(ut_params->op->status,
9735                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9736                         "Authentication failed");
9737         return 0;
9738 }
9739
9740 static int
9741 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
9742 {
9743         return test_authenticated_decryption_oop(&gcm_test_case_5);
9744 }
9745
9746 static int
9747 test_authenticated_encryption_sessionless(
9748                 const struct aead_test_data *tdata)
9749 {
9750         struct crypto_testsuite_params *ts_params = &testsuite_params;
9751         struct crypto_unittest_params *ut_params = &unittest_params;
9752
9753         int retval;
9754         uint8_t *ciphertext, *auth_tag;
9755         uint16_t plaintext_pad_len;
9756         uint8_t key[tdata->key.len + 1];
9757         struct rte_cryptodev_info dev_info;
9758
9759         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9760         uint64_t feat_flags = dev_info.feature_flags;
9761
9762         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9763                 printf("Device doesn't support Sessionless ops.\n");
9764                 return -ENOTSUP;
9765         }
9766
9767         /* not supported with CPU crypto */
9768         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9769                 return -ENOTSUP;
9770
9771         /* Verify the capabilities */
9772         struct rte_cryptodev_sym_capability_idx cap_idx;
9773         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9774         cap_idx.algo.aead = tdata->algo;
9775         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9776                         &cap_idx) == NULL)
9777                 return -ENOTSUP;
9778
9779         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9780
9781         /* clear mbuf payload */
9782         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9783                         rte_pktmbuf_tailroom(ut_params->ibuf));
9784
9785         /* Create AEAD operation */
9786         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
9787         if (retval < 0)
9788                 return retval;
9789
9790         /* Create GCM xform */
9791         memcpy(key, tdata->key.data, tdata->key.len);
9792         retval = create_aead_xform(ut_params->op,
9793                         tdata->algo,
9794                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
9795                         key, tdata->key.len,
9796                         tdata->aad.len, tdata->auth_tag.len,
9797                         tdata->iv.len);
9798         if (retval < 0)
9799                 return retval;
9800
9801         ut_params->op->sym->m_src = ut_params->ibuf;
9802
9803         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9804                         RTE_CRYPTO_OP_SESSIONLESS,
9805                         "crypto op session type not sessionless");
9806
9807         /* Process crypto operation */
9808         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
9809                         ut_params->op), "failed to process sym crypto op");
9810
9811         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9812
9813         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9814                         "crypto op status not success");
9815
9816         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
9817
9818         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9819                         ut_params->op->sym->cipher.data.offset);
9820         auth_tag = ciphertext + plaintext_pad_len;
9821
9822         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
9823         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
9824
9825         /* Validate obuf */
9826         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9827                         ciphertext,
9828                         tdata->ciphertext.data,
9829                         tdata->ciphertext.len,
9830                         "Ciphertext data not as expected");
9831
9832         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9833                         auth_tag,
9834                         tdata->auth_tag.data,
9835                         tdata->auth_tag.len,
9836                         "Generated auth tag not as expected");
9837
9838         return 0;
9839
9840 }
9841
9842 static int
9843 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
9844 {
9845         return test_authenticated_encryption_sessionless(
9846                         &gcm_test_case_5);
9847 }
9848
9849 static int
9850 test_authenticated_decryption_sessionless(
9851                 const struct aead_test_data *tdata)
9852 {
9853         struct crypto_testsuite_params *ts_params = &testsuite_params;
9854         struct crypto_unittest_params *ut_params = &unittest_params;
9855
9856         int retval;
9857         uint8_t *plaintext;
9858         uint8_t key[tdata->key.len + 1];
9859         struct rte_cryptodev_info dev_info;
9860
9861         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9862         uint64_t feat_flags = dev_info.feature_flags;
9863
9864         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
9865                 printf("Device doesn't support Sessionless ops.\n");
9866                 return -ENOTSUP;
9867         }
9868
9869         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
9870                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
9871                 printf("Device doesn't support RAW data-path APIs.\n");
9872                 return -ENOTSUP;
9873         }
9874
9875         /* not supported with CPU crypto */
9876         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
9877                 return -ENOTSUP;
9878
9879         /* Verify the capabilities */
9880         struct rte_cryptodev_sym_capability_idx cap_idx;
9881         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
9882         cap_idx.algo.aead = tdata->algo;
9883         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
9884                         &cap_idx) == NULL)
9885                 return -ENOTSUP;
9886
9887         /* alloc mbuf and set payload */
9888         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9889
9890         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9891                         rte_pktmbuf_tailroom(ut_params->ibuf));
9892
9893         /* Create AEAD operation */
9894         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
9895         if (retval < 0)
9896                 return retval;
9897
9898         /* Create AEAD xform */
9899         memcpy(key, tdata->key.data, tdata->key.len);
9900         retval = create_aead_xform(ut_params->op,
9901                         tdata->algo,
9902                         RTE_CRYPTO_AEAD_OP_DECRYPT,
9903                         key, tdata->key.len,
9904                         tdata->aad.len, tdata->auth_tag.len,
9905                         tdata->iv.len);
9906         if (retval < 0)
9907                 return retval;
9908
9909         ut_params->op->sym->m_src = ut_params->ibuf;
9910
9911         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
9912                         RTE_CRYPTO_OP_SESSIONLESS,
9913                         "crypto op session type not sessionless");
9914
9915         /* Process crypto operation */
9916         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
9917                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
9918                                 ut_params->op, 0, 0, 0, 0);
9919         else
9920                 TEST_ASSERT_NOT_NULL(process_crypto_request(
9921                         ts_params->valid_devs[0], ut_params->op),
9922                                 "failed to process sym crypto op");
9923
9924         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
9925
9926         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
9927                         "crypto op status not success");
9928
9929         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
9930                         ut_params->op->sym->cipher.data.offset);
9931
9932         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
9933
9934         /* Validate obuf */
9935         TEST_ASSERT_BUFFERS_ARE_EQUAL(
9936                         plaintext,
9937                         tdata->plaintext.data,
9938                         tdata->plaintext.len,
9939                         "Plaintext data not as expected");
9940
9941         TEST_ASSERT_EQUAL(ut_params->op->status,
9942                         RTE_CRYPTO_OP_STATUS_SUCCESS,
9943                         "Authentication failed");
9944         return 0;
9945 }
9946
9947 static int
9948 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
9949 {
9950         return test_authenticated_decryption_sessionless(
9951                         &gcm_test_case_5);
9952 }
9953
9954 static int
9955 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
9956 {
9957         return test_authenticated_encryption(&ccm_test_case_128_1);
9958 }
9959
9960 static int
9961 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
9962 {
9963         return test_authenticated_encryption(&ccm_test_case_128_2);
9964 }
9965
9966 static int
9967 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
9968 {
9969         return test_authenticated_encryption(&ccm_test_case_128_3);
9970 }
9971
9972 static int
9973 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
9974 {
9975         return test_authenticated_decryption(&ccm_test_case_128_1);
9976 }
9977
9978 static int
9979 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
9980 {
9981         return test_authenticated_decryption(&ccm_test_case_128_2);
9982 }
9983
9984 static int
9985 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
9986 {
9987         return test_authenticated_decryption(&ccm_test_case_128_3);
9988 }
9989
9990 static int
9991 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
9992 {
9993         return test_authenticated_encryption(&ccm_test_case_192_1);
9994 }
9995
9996 static int
9997 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
9998 {
9999         return test_authenticated_encryption(&ccm_test_case_192_2);
10000 }
10001
10002 static int
10003 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
10004 {
10005         return test_authenticated_encryption(&ccm_test_case_192_3);
10006 }
10007
10008 static int
10009 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
10010 {
10011         return test_authenticated_decryption(&ccm_test_case_192_1);
10012 }
10013
10014 static int
10015 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
10016 {
10017         return test_authenticated_decryption(&ccm_test_case_192_2);
10018 }
10019
10020 static int
10021 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
10022 {
10023         return test_authenticated_decryption(&ccm_test_case_192_3);
10024 }
10025
10026 static int
10027 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
10028 {
10029         return test_authenticated_encryption(&ccm_test_case_256_1);
10030 }
10031
10032 static int
10033 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
10034 {
10035         return test_authenticated_encryption(&ccm_test_case_256_2);
10036 }
10037
10038 static int
10039 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
10040 {
10041         return test_authenticated_encryption(&ccm_test_case_256_3);
10042 }
10043
10044 static int
10045 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
10046 {
10047         return test_authenticated_decryption(&ccm_test_case_256_1);
10048 }
10049
10050 static int
10051 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
10052 {
10053         return test_authenticated_decryption(&ccm_test_case_256_2);
10054 }
10055
10056 static int
10057 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
10058 {
10059         return test_authenticated_decryption(&ccm_test_case_256_3);
10060 }
10061
10062 static int
10063 test_stats(void)
10064 {
10065         struct crypto_testsuite_params *ts_params = &testsuite_params;
10066         struct rte_cryptodev_stats stats;
10067
10068         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10069                 return -ENOTSUP;
10070
10071         /* Verify the capabilities */
10072         struct rte_cryptodev_sym_capability_idx cap_idx;
10073         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10074         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
10075         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10076                         &cap_idx) == NULL)
10077                 return -ENOTSUP;
10078         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10079         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10080         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10081                         &cap_idx) == NULL)
10082                 return -ENOTSUP;
10083
10084         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
10085                         == -ENOTSUP)
10086                 return -ENOTSUP;
10087
10088         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10089         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
10090                         &stats) == -ENODEV),
10091                 "rte_cryptodev_stats_get invalid dev failed");
10092         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
10093                 "rte_cryptodev_stats_get invalid Param failed");
10094
10095         /* Test expected values */
10096         test_AES_CBC_HMAC_SHA1_encrypt_digest();
10097         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10098                         &stats),
10099                 "rte_cryptodev_stats_get failed");
10100         TEST_ASSERT((stats.enqueued_count == 1),
10101                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10102         TEST_ASSERT((stats.dequeued_count == 1),
10103                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10104         TEST_ASSERT((stats.enqueue_err_count == 0),
10105                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10106         TEST_ASSERT((stats.dequeue_err_count == 0),
10107                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10108
10109         /* invalid device but should ignore and not reset device stats*/
10110         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
10111         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10112                         &stats),
10113                 "rte_cryptodev_stats_get failed");
10114         TEST_ASSERT((stats.enqueued_count == 1),
10115                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10116
10117         /* check that a valid reset clears stats */
10118         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
10119         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
10120                         &stats),
10121                                           "rte_cryptodev_stats_get failed");
10122         TEST_ASSERT((stats.enqueued_count == 0),
10123                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10124         TEST_ASSERT((stats.dequeued_count == 0),
10125                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
10126
10127         return TEST_SUCCESS;
10128 }
10129
10130 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
10131                                    struct crypto_unittest_params *ut_params,
10132                                    enum rte_crypto_auth_operation op,
10133                                    const struct HMAC_MD5_vector *test_case)
10134 {
10135         uint8_t key[64];
10136
10137         memcpy(key, test_case->key.data, test_case->key.len);
10138
10139         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10140         ut_params->auth_xform.next = NULL;
10141         ut_params->auth_xform.auth.op = op;
10142
10143         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
10144
10145         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
10146         ut_params->auth_xform.auth.key.length = test_case->key.len;
10147         ut_params->auth_xform.auth.key.data = key;
10148
10149         ut_params->sess = rte_cryptodev_sym_session_create(
10150                         ts_params->session_mpool);
10151
10152         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10153                         ut_params->sess, &ut_params->auth_xform,
10154                         ts_params->session_priv_mpool);
10155
10156         if (ut_params->sess == NULL)
10157                 return TEST_FAILED;
10158
10159         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10160
10161         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10162                         rte_pktmbuf_tailroom(ut_params->ibuf));
10163
10164         return 0;
10165 }
10166
10167 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
10168                               const struct HMAC_MD5_vector *test_case,
10169                               uint8_t **plaintext)
10170 {
10171         uint16_t plaintext_pad_len;
10172
10173         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
10174
10175         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10176                                 16);
10177
10178         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10179                         plaintext_pad_len);
10180         memcpy(*plaintext, test_case->plaintext.data,
10181                         test_case->plaintext.len);
10182
10183         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10184                         ut_params->ibuf, MD5_DIGEST_LEN);
10185         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10186                         "no room to append digest");
10187         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10188                         ut_params->ibuf, plaintext_pad_len);
10189
10190         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10191                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
10192                            test_case->auth_tag.len);
10193         }
10194
10195         sym_op->auth.data.offset = 0;
10196         sym_op->auth.data.length = test_case->plaintext.len;
10197
10198         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10199         ut_params->op->sym->m_src = ut_params->ibuf;
10200
10201         return 0;
10202 }
10203
10204 static int
10205 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
10206 {
10207         uint16_t plaintext_pad_len;
10208         uint8_t *plaintext, *auth_tag;
10209
10210         struct crypto_testsuite_params *ts_params = &testsuite_params;
10211         struct crypto_unittest_params *ut_params = &unittest_params;
10212         struct rte_cryptodev_info dev_info;
10213
10214         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10215         uint64_t feat_flags = dev_info.feature_flags;
10216
10217         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10218                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10219                 printf("Device doesn't support RAW data-path APIs.\n");
10220                 return -ENOTSUP;
10221         }
10222
10223         /* Verify the capabilities */
10224         struct rte_cryptodev_sym_capability_idx cap_idx;
10225         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10226         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10227         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10228                         &cap_idx) == NULL)
10229                 return -ENOTSUP;
10230
10231         if (MD5_HMAC_create_session(ts_params, ut_params,
10232                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
10233                 return TEST_FAILED;
10234
10235         /* Generate Crypto op data structure */
10236         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10237                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10238         TEST_ASSERT_NOT_NULL(ut_params->op,
10239                         "Failed to allocate symmetric crypto operation struct");
10240
10241         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
10242                                 16);
10243
10244         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10245                 return TEST_FAILED;
10246
10247         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10248                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10249                         ut_params->op);
10250         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10251                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10252                                 ut_params->op, 0, 1, 0, 0);
10253         else
10254                 TEST_ASSERT_NOT_NULL(
10255                         process_crypto_request(ts_params->valid_devs[0],
10256                                 ut_params->op),
10257                                 "failed to process sym crypto op");
10258
10259         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10260                         "crypto op processing failed");
10261
10262         if (ut_params->op->sym->m_dst) {
10263                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10264                                 uint8_t *, plaintext_pad_len);
10265         } else {
10266                 auth_tag = plaintext + plaintext_pad_len;
10267         }
10268
10269         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10270                         auth_tag,
10271                         test_case->auth_tag.data,
10272                         test_case->auth_tag.len,
10273                         "HMAC_MD5 generated tag not as expected");
10274
10275         return TEST_SUCCESS;
10276 }
10277
10278 static int
10279 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
10280 {
10281         uint8_t *plaintext;
10282
10283         struct crypto_testsuite_params *ts_params = &testsuite_params;
10284         struct crypto_unittest_params *ut_params = &unittest_params;
10285         struct rte_cryptodev_info dev_info;
10286
10287         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10288         uint64_t feat_flags = dev_info.feature_flags;
10289
10290         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10291                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10292                 printf("Device doesn't support RAW data-path APIs.\n");
10293                 return -ENOTSUP;
10294         }
10295
10296         /* Verify the capabilities */
10297         struct rte_cryptodev_sym_capability_idx cap_idx;
10298         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10299         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
10300         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10301                         &cap_idx) == NULL)
10302                 return -ENOTSUP;
10303
10304         if (MD5_HMAC_create_session(ts_params, ut_params,
10305                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
10306                 return TEST_FAILED;
10307         }
10308
10309         /* Generate Crypto op data structure */
10310         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10311                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10312         TEST_ASSERT_NOT_NULL(ut_params->op,
10313                         "Failed to allocate symmetric crypto operation struct");
10314
10315         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
10316                 return TEST_FAILED;
10317
10318         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10319                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10320                         ut_params->op);
10321         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10322                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10323                                 ut_params->op, 0, 1, 0, 0);
10324         else
10325                 TEST_ASSERT_NOT_NULL(
10326                         process_crypto_request(ts_params->valid_devs[0],
10327                                 ut_params->op),
10328                                 "failed to process sym crypto op");
10329
10330         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10331                         "HMAC_MD5 crypto op processing failed");
10332
10333         return TEST_SUCCESS;
10334 }
10335
10336 static int
10337 test_MD5_HMAC_generate_case_1(void)
10338 {
10339         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
10340 }
10341
10342 static int
10343 test_MD5_HMAC_verify_case_1(void)
10344 {
10345         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
10346 }
10347
10348 static int
10349 test_MD5_HMAC_generate_case_2(void)
10350 {
10351         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
10352 }
10353
10354 static int
10355 test_MD5_HMAC_verify_case_2(void)
10356 {
10357         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
10358 }
10359
10360 static int
10361 test_multi_session(void)
10362 {
10363         struct crypto_testsuite_params *ts_params = &testsuite_params;
10364         struct crypto_unittest_params *ut_params = &unittest_params;
10365
10366         struct rte_cryptodev_info dev_info;
10367         struct rte_cryptodev_sym_session **sessions;
10368
10369         uint16_t i;
10370
10371         /* Verify the capabilities */
10372         struct rte_cryptodev_sym_capability_idx cap_idx;
10373         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10374         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10375         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10376                         &cap_idx) == NULL)
10377                 return -ENOTSUP;
10378         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10379         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10380         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10381                         &cap_idx) == NULL)
10382                 return -ENOTSUP;
10383
10384         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
10385                         aes_cbc_key, hmac_sha512_key);
10386
10387
10388         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10389
10390         sessions = rte_malloc(NULL,
10391                         (sizeof(struct rte_cryptodev_sym_session *) *
10392                         MAX_NB_SESSIONS) + 1, 0);
10393
10394         /* Create multiple crypto sessions*/
10395         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10396
10397                 sessions[i] = rte_cryptodev_sym_session_create(
10398                                 ts_params->session_mpool);
10399
10400                 rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10401                                 sessions[i], &ut_params->auth_xform,
10402                                 ts_params->session_priv_mpool);
10403                 TEST_ASSERT_NOT_NULL(sessions[i],
10404                                 "Session creation failed at session number %u",
10405                                 i);
10406
10407                 /* Attempt to send a request on each session */
10408                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
10409                         sessions[i],
10410                         ut_params,
10411                         ts_params,
10412                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
10413                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
10414                         aes_cbc_iv),
10415                         "Failed to perform decrypt on request number %u.", i);
10416                 /* free crypto operation structure */
10417                 if (ut_params->op)
10418                         rte_crypto_op_free(ut_params->op);
10419
10420                 /*
10421                  * free mbuf - both obuf and ibuf are usually the same,
10422                  * so check if they point at the same address is necessary,
10423                  * to avoid freeing the mbuf twice.
10424                  */
10425                 if (ut_params->obuf) {
10426                         rte_pktmbuf_free(ut_params->obuf);
10427                         if (ut_params->ibuf == ut_params->obuf)
10428                                 ut_params->ibuf = 0;
10429                         ut_params->obuf = 0;
10430                 }
10431                 if (ut_params->ibuf) {
10432                         rte_pktmbuf_free(ut_params->ibuf);
10433                         ut_params->ibuf = 0;
10434                 }
10435         }
10436
10437         /* Next session create should fail */
10438         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10439                         sessions[i], &ut_params->auth_xform,
10440                         ts_params->session_priv_mpool);
10441         TEST_ASSERT_NULL(sessions[i],
10442                         "Session creation succeeded unexpectedly!");
10443
10444         for (i = 0; i < MAX_NB_SESSIONS; i++) {
10445                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10446                                 sessions[i]);
10447                 rte_cryptodev_sym_session_free(sessions[i]);
10448         }
10449
10450         rte_free(sessions);
10451
10452         return TEST_SUCCESS;
10453 }
10454
10455 struct multi_session_params {
10456         struct crypto_unittest_params ut_params;
10457         uint8_t *cipher_key;
10458         uint8_t *hmac_key;
10459         const uint8_t *cipher;
10460         const uint8_t *digest;
10461         uint8_t *iv;
10462 };
10463
10464 #define MB_SESSION_NUMBER 3
10465
10466 static int
10467 test_multi_session_random_usage(void)
10468 {
10469         struct crypto_testsuite_params *ts_params = &testsuite_params;
10470         struct rte_cryptodev_info dev_info;
10471         struct rte_cryptodev_sym_session **sessions;
10472         uint32_t i, j;
10473         struct multi_session_params ut_paramz[] = {
10474
10475                 {
10476                         .cipher_key = ms_aes_cbc_key0,
10477                         .hmac_key = ms_hmac_key0,
10478                         .cipher = ms_aes_cbc_cipher0,
10479                         .digest = ms_hmac_digest0,
10480                         .iv = ms_aes_cbc_iv0
10481                 },
10482                 {
10483                         .cipher_key = ms_aes_cbc_key1,
10484                         .hmac_key = ms_hmac_key1,
10485                         .cipher = ms_aes_cbc_cipher1,
10486                         .digest = ms_hmac_digest1,
10487                         .iv = ms_aes_cbc_iv1
10488                 },
10489                 {
10490                         .cipher_key = ms_aes_cbc_key2,
10491                         .hmac_key = ms_hmac_key2,
10492                         .cipher = ms_aes_cbc_cipher2,
10493                         .digest = ms_hmac_digest2,
10494                         .iv = ms_aes_cbc_iv2
10495                 },
10496
10497         };
10498
10499         /* Verify the capabilities */
10500         struct rte_cryptodev_sym_capability_idx cap_idx;
10501         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10502         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
10503         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10504                         &cap_idx) == NULL)
10505                 return -ENOTSUP;
10506         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10507         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
10508         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10509                         &cap_idx) == NULL)
10510                 return -ENOTSUP;
10511
10512         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10513
10514         sessions = rte_malloc(NULL,
10515                         (sizeof(struct rte_cryptodev_sym_session *)
10516                                         * MAX_NB_SESSIONS) + 1, 0);
10517
10518         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10519                 sessions[i] = rte_cryptodev_sym_session_create(
10520                                 ts_params->session_mpool);
10521
10522                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
10523                                 sizeof(struct crypto_unittest_params));
10524
10525                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
10526                                 &ut_paramz[i].ut_params,
10527                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
10528
10529                 /* Create multiple crypto sessions*/
10530                 rte_cryptodev_sym_session_init(
10531                                 ts_params->valid_devs[0],
10532                                 sessions[i],
10533                                 &ut_paramz[i].ut_params.auth_xform,
10534                                 ts_params->session_priv_mpool);
10535
10536                 TEST_ASSERT_NOT_NULL(sessions[i],
10537                                 "Session creation failed at session number %u",
10538                                 i);
10539
10540         }
10541
10542         srand(time(NULL));
10543         for (i = 0; i < 40000; i++) {
10544
10545                 j = rand() % MB_SESSION_NUMBER;
10546
10547                 TEST_ASSERT_SUCCESS(
10548                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
10549                                         sessions[j],
10550                                         &ut_paramz[j].ut_params,
10551                                         ts_params, ut_paramz[j].cipher,
10552                                         ut_paramz[j].digest,
10553                                         ut_paramz[j].iv),
10554                         "Failed to perform decrypt on request number %u.", i);
10555
10556                 if (ut_paramz[j].ut_params.op)
10557                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
10558
10559                 /*
10560                  * free mbuf - both obuf and ibuf are usually the same,
10561                  * so check if they point at the same address is necessary,
10562                  * to avoid freeing the mbuf twice.
10563                  */
10564                 if (ut_paramz[j].ut_params.obuf) {
10565                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
10566                         if (ut_paramz[j].ut_params.ibuf
10567                                         == ut_paramz[j].ut_params.obuf)
10568                                 ut_paramz[j].ut_params.ibuf = 0;
10569                         ut_paramz[j].ut_params.obuf = 0;
10570                 }
10571                 if (ut_paramz[j].ut_params.ibuf) {
10572                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
10573                         ut_paramz[j].ut_params.ibuf = 0;
10574                 }
10575         }
10576
10577         for (i = 0; i < MB_SESSION_NUMBER; i++) {
10578                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
10579                                 sessions[i]);
10580                 rte_cryptodev_sym_session_free(sessions[i]);
10581         }
10582
10583         rte_free(sessions);
10584
10585         return TEST_SUCCESS;
10586 }
10587
10588 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
10589                         0xab, 0xab, 0xab, 0xab,
10590                         0xab, 0xab, 0xab, 0xab,
10591                         0xab, 0xab, 0xab, 0xab};
10592
10593 static int
10594 test_null_invalid_operation(void)
10595 {
10596         struct crypto_testsuite_params *ts_params = &testsuite_params;
10597         struct crypto_unittest_params *ut_params = &unittest_params;
10598         int ret;
10599
10600         /* This test is for NULL PMD only */
10601         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10602                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10603                 return -ENOTSUP;
10604
10605         /* Setup Cipher Parameters */
10606         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10607         ut_params->cipher_xform.next = NULL;
10608
10609         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
10610         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10611
10612         ut_params->sess = rte_cryptodev_sym_session_create(
10613                         ts_params->session_mpool);
10614
10615         /* Create Crypto session*/
10616         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10617                         ut_params->sess, &ut_params->cipher_xform,
10618                         ts_params->session_priv_mpool);
10619         TEST_ASSERT(ret < 0,
10620                         "Session creation succeeded unexpectedly");
10621
10622
10623         /* Setup HMAC Parameters */
10624         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10625         ut_params->auth_xform.next = NULL;
10626
10627         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
10628         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10629
10630         ut_params->sess = rte_cryptodev_sym_session_create(
10631                         ts_params->session_mpool);
10632
10633         /* Create Crypto session*/
10634         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10635                         ut_params->sess, &ut_params->auth_xform,
10636                         ts_params->session_priv_mpool);
10637         TEST_ASSERT(ret < 0,
10638                         "Session creation succeeded unexpectedly");
10639
10640         return TEST_SUCCESS;
10641 }
10642
10643
10644 #define NULL_BURST_LENGTH (32)
10645
10646 static int
10647 test_null_burst_operation(void)
10648 {
10649         struct crypto_testsuite_params *ts_params = &testsuite_params;
10650         struct crypto_unittest_params *ut_params = &unittest_params;
10651
10652         unsigned i, burst_len = NULL_BURST_LENGTH;
10653
10654         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
10655         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
10656
10657         /* This test is for NULL PMD only */
10658         if (gbl_driver_id != rte_cryptodev_driver_id_get(
10659                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
10660                 return -ENOTSUP;
10661
10662         /* Setup Cipher Parameters */
10663         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10664         ut_params->cipher_xform.next = &ut_params->auth_xform;
10665
10666         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
10667         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10668
10669         /* Setup HMAC Parameters */
10670         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10671         ut_params->auth_xform.next = NULL;
10672
10673         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
10674         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
10675
10676         ut_params->sess = rte_cryptodev_sym_session_create(
10677                         ts_params->session_mpool);
10678
10679         /* Create Crypto session*/
10680         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
10681                         ut_params->sess, &ut_params->cipher_xform,
10682                         ts_params->session_priv_mpool);
10683         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10684
10685         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
10686                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
10687                         burst_len, "failed to generate burst of crypto ops");
10688
10689         /* Generate an operation for each mbuf in burst */
10690         for (i = 0; i < burst_len; i++) {
10691                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10692
10693                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
10694
10695                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
10696                                 sizeof(unsigned));
10697                 *data = i;
10698
10699                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
10700
10701                 burst[i]->sym->m_src = m;
10702         }
10703
10704         /* Process crypto operation */
10705         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
10706                         0, burst, burst_len),
10707                         burst_len,
10708                         "Error enqueuing burst");
10709
10710         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
10711                         0, burst_dequeued, burst_len),
10712                         burst_len,
10713                         "Error dequeuing burst");
10714
10715
10716         for (i = 0; i < burst_len; i++) {
10717                 TEST_ASSERT_EQUAL(
10718                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
10719                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
10720                                         uint32_t *),
10721                         "data not as expected");
10722
10723                 rte_pktmbuf_free(burst[i]->sym->m_src);
10724                 rte_crypto_op_free(burst[i]);
10725         }
10726
10727         return TEST_SUCCESS;
10728 }
10729
10730 static void
10731 generate_gmac_large_plaintext(uint8_t *data)
10732 {
10733         uint16_t i;
10734
10735         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
10736                 memcpy(&data[i], &data[0], 32);
10737 }
10738
10739 static int
10740 create_gmac_operation(enum rte_crypto_auth_operation op,
10741                 const struct gmac_test_data *tdata)
10742 {
10743         struct crypto_testsuite_params *ts_params = &testsuite_params;
10744         struct crypto_unittest_params *ut_params = &unittest_params;
10745         struct rte_crypto_sym_op *sym_op;
10746
10747         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10748
10749         /* Generate Crypto op data structure */
10750         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10751                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10752         TEST_ASSERT_NOT_NULL(ut_params->op,
10753                         "Failed to allocate symmetric crypto operation struct");
10754
10755         sym_op = ut_params->op->sym;
10756
10757         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
10758                         ut_params->ibuf, tdata->gmac_tag.len);
10759         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10760                         "no room to append digest");
10761
10762         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
10763                         ut_params->ibuf, plaintext_pad_len);
10764
10765         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10766                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10767                                 tdata->gmac_tag.len);
10768                 debug_hexdump(stdout, "digest:",
10769                                 sym_op->auth.digest.data,
10770                                 tdata->gmac_tag.len);
10771         }
10772
10773         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10774                         uint8_t *, IV_OFFSET);
10775
10776         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10777
10778         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10779
10780         sym_op->cipher.data.length = 0;
10781         sym_op->cipher.data.offset = 0;
10782
10783         sym_op->auth.data.offset = 0;
10784         sym_op->auth.data.length = tdata->plaintext.len;
10785
10786         return 0;
10787 }
10788
10789 static int
10790 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
10791                 const struct gmac_test_data *tdata,
10792                 void *digest_mem, uint64_t digest_phys)
10793 {
10794         struct crypto_testsuite_params *ts_params = &testsuite_params;
10795         struct crypto_unittest_params *ut_params = &unittest_params;
10796         struct rte_crypto_sym_op *sym_op;
10797
10798         /* Generate Crypto op data structure */
10799         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10800                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10801         TEST_ASSERT_NOT_NULL(ut_params->op,
10802                         "Failed to allocate symmetric crypto operation struct");
10803
10804         sym_op = ut_params->op->sym;
10805
10806         sym_op->auth.digest.data = digest_mem;
10807         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
10808                         "no room to append digest");
10809
10810         sym_op->auth.digest.phys_addr = digest_phys;
10811
10812         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
10813                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
10814                                 tdata->gmac_tag.len);
10815                 debug_hexdump(stdout, "digest:",
10816                                 sym_op->auth.digest.data,
10817                                 tdata->gmac_tag.len);
10818         }
10819
10820         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
10821                         uint8_t *, IV_OFFSET);
10822
10823         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
10824
10825         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
10826
10827         sym_op->cipher.data.length = 0;
10828         sym_op->cipher.data.offset = 0;
10829
10830         sym_op->auth.data.offset = 0;
10831         sym_op->auth.data.length = tdata->plaintext.len;
10832
10833         return 0;
10834 }
10835
10836 static int create_gmac_session(uint8_t dev_id,
10837                 const struct gmac_test_data *tdata,
10838                 enum rte_crypto_auth_operation auth_op)
10839 {
10840         uint8_t auth_key[tdata->key.len];
10841
10842         struct crypto_testsuite_params *ts_params = &testsuite_params;
10843         struct crypto_unittest_params *ut_params = &unittest_params;
10844
10845         memcpy(auth_key, tdata->key.data, tdata->key.len);
10846
10847         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10848         ut_params->auth_xform.next = NULL;
10849
10850         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
10851         ut_params->auth_xform.auth.op = auth_op;
10852         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
10853         ut_params->auth_xform.auth.key.length = tdata->key.len;
10854         ut_params->auth_xform.auth.key.data = auth_key;
10855         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
10856         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
10857
10858
10859         ut_params->sess = rte_cryptodev_sym_session_create(
10860                         ts_params->session_mpool);
10861
10862         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
10863                         &ut_params->auth_xform,
10864                         ts_params->session_priv_mpool);
10865
10866         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
10867
10868         return 0;
10869 }
10870
10871 static int
10872 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
10873 {
10874         struct crypto_testsuite_params *ts_params = &testsuite_params;
10875         struct crypto_unittest_params *ut_params = &unittest_params;
10876         struct rte_cryptodev_info dev_info;
10877
10878         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10879         uint64_t feat_flags = dev_info.feature_flags;
10880
10881         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10882                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10883                 printf("Device doesn't support RAW data-path APIs.\n");
10884                 return -ENOTSUP;
10885         }
10886
10887         int retval;
10888
10889         uint8_t *auth_tag, *plaintext;
10890         uint16_t plaintext_pad_len;
10891
10892         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
10893                               "No GMAC length in the source data");
10894
10895         /* Verify the capabilities */
10896         struct rte_cryptodev_sym_capability_idx cap_idx;
10897         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
10898         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
10899         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10900                         &cap_idx) == NULL)
10901                 return -ENOTSUP;
10902
10903         retval = create_gmac_session(ts_params->valid_devs[0],
10904                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
10905
10906         if (retval < 0)
10907                 return retval;
10908
10909         if (tdata->plaintext.len > MBUF_SIZE)
10910                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10911         else
10912                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10913         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
10914                         "Failed to allocate input buffer in mempool");
10915
10916         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10917                         rte_pktmbuf_tailroom(ut_params->ibuf));
10918
10919         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10920         /*
10921          * Runtime generate the large plain text instead of use hard code
10922          * plain text vector. It is done to avoid create huge source file
10923          * with the test vector.
10924          */
10925         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
10926                 generate_gmac_large_plaintext(tdata->plaintext.data);
10927
10928         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10929                                 plaintext_pad_len);
10930         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
10931
10932         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
10933         debug_hexdump(stdout, "plaintext:", plaintext,
10934                         tdata->plaintext.len);
10935
10936         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
10937                         tdata);
10938
10939         if (retval < 0)
10940                 return retval;
10941
10942         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10943
10944         ut_params->op->sym->m_src = ut_params->ibuf;
10945
10946         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10947                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
10948                         ut_params->op);
10949         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10950                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10951                                 ut_params->op, 0, 1, 0, 0);
10952         else
10953                 TEST_ASSERT_NOT_NULL(
10954                         process_crypto_request(ts_params->valid_devs[0],
10955                         ut_params->op), "failed to process sym crypto op");
10956
10957         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10958                         "crypto op processing failed");
10959
10960         if (ut_params->op->sym->m_dst) {
10961                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
10962                                 uint8_t *, plaintext_pad_len);
10963         } else {
10964                 auth_tag = plaintext + plaintext_pad_len;
10965         }
10966
10967         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
10968
10969         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10970                         auth_tag,
10971                         tdata->gmac_tag.data,
10972                         tdata->gmac_tag.len,
10973                         "GMAC Generated auth tag not as expected");
10974
10975         return 0;
10976 }
10977
10978 static int
10979 test_AES_GMAC_authentication_test_case_1(void)
10980 {
10981         return test_AES_GMAC_authentication(&gmac_test_case_1);
10982 }
10983
10984 static int
10985 test_AES_GMAC_authentication_test_case_2(void)
10986 {
10987         return test_AES_GMAC_authentication(&gmac_test_case_2);
10988 }
10989
10990 static int
10991 test_AES_GMAC_authentication_test_case_3(void)
10992 {
10993         return test_AES_GMAC_authentication(&gmac_test_case_3);
10994 }
10995
10996 static int
10997 test_AES_GMAC_authentication_test_case_4(void)
10998 {
10999         return test_AES_GMAC_authentication(&gmac_test_case_4);
11000 }
11001
11002 static int
11003 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
11004 {
11005         struct crypto_testsuite_params *ts_params = &testsuite_params;
11006         struct crypto_unittest_params *ut_params = &unittest_params;
11007         int retval;
11008         uint32_t plaintext_pad_len;
11009         uint8_t *plaintext;
11010         struct rte_cryptodev_info dev_info;
11011
11012         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11013         uint64_t feat_flags = dev_info.feature_flags;
11014
11015         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11016                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11017                 printf("Device doesn't support RAW data-path APIs.\n");
11018                 return -ENOTSUP;
11019         }
11020
11021         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11022                               "No GMAC length in the source data");
11023
11024         /* Verify the capabilities */
11025         struct rte_cryptodev_sym_capability_idx cap_idx;
11026         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11027         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11028         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11029                         &cap_idx) == NULL)
11030                 return -ENOTSUP;
11031
11032         retval = create_gmac_session(ts_params->valid_devs[0],
11033                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
11034
11035         if (retval < 0)
11036                 return retval;
11037
11038         if (tdata->plaintext.len > MBUF_SIZE)
11039                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
11040         else
11041                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11042         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11043                         "Failed to allocate input buffer in mempool");
11044
11045         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11046                         rte_pktmbuf_tailroom(ut_params->ibuf));
11047
11048         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11049
11050         /*
11051          * Runtime generate the large plain text instead of use hard code
11052          * plain text vector. It is done to avoid create huge source file
11053          * with the test vector.
11054          */
11055         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
11056                 generate_gmac_large_plaintext(tdata->plaintext.data);
11057
11058         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11059                                 plaintext_pad_len);
11060         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11061
11062         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
11063         debug_hexdump(stdout, "plaintext:", plaintext,
11064                         tdata->plaintext.len);
11065
11066         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
11067                         tdata);
11068
11069         if (retval < 0)
11070                 return retval;
11071
11072         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11073
11074         ut_params->op->sym->m_src = ut_params->ibuf;
11075
11076         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11077                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11078                         ut_params->op);
11079         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11080                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11081                                 ut_params->op, 0, 1, 0, 0);
11082         else
11083                 TEST_ASSERT_NOT_NULL(
11084                         process_crypto_request(ts_params->valid_devs[0],
11085                         ut_params->op), "failed to process sym crypto op");
11086
11087         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11088                         "crypto op processing failed");
11089
11090         return 0;
11091
11092 }
11093
11094 static int
11095 test_AES_GMAC_authentication_verify_test_case_1(void)
11096 {
11097         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
11098 }
11099
11100 static int
11101 test_AES_GMAC_authentication_verify_test_case_2(void)
11102 {
11103         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
11104 }
11105
11106 static int
11107 test_AES_GMAC_authentication_verify_test_case_3(void)
11108 {
11109         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
11110 }
11111
11112 static int
11113 test_AES_GMAC_authentication_verify_test_case_4(void)
11114 {
11115         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
11116 }
11117
11118 static int
11119 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
11120                                 uint32_t fragsz)
11121 {
11122         struct crypto_testsuite_params *ts_params = &testsuite_params;
11123         struct crypto_unittest_params *ut_params = &unittest_params;
11124         struct rte_cryptodev_info dev_info;
11125         uint64_t feature_flags;
11126         unsigned int trn_data = 0;
11127         void *digest_mem = NULL;
11128         uint32_t segs = 1;
11129         unsigned int to_trn = 0;
11130         struct rte_mbuf *buf = NULL;
11131         uint8_t *auth_tag, *plaintext;
11132         int retval;
11133
11134         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
11135                               "No GMAC length in the source data");
11136
11137         /* Verify the capabilities */
11138         struct rte_cryptodev_sym_capability_idx cap_idx;
11139         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11140         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
11141         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11142                         &cap_idx) == NULL)
11143                 return -ENOTSUP;
11144
11145         /* Check for any input SGL support */
11146         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11147         feature_flags = dev_info.feature_flags;
11148
11149         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
11150                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
11151                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
11152                 return -ENOTSUP;
11153
11154         if (fragsz > tdata->plaintext.len)
11155                 fragsz = tdata->plaintext.len;
11156
11157         uint16_t plaintext_len = fragsz;
11158
11159         retval = create_gmac_session(ts_params->valid_devs[0],
11160                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
11161
11162         if (retval < 0)
11163                 return retval;
11164
11165         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11166         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11167                         "Failed to allocate input buffer in mempool");
11168
11169         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11170                         rte_pktmbuf_tailroom(ut_params->ibuf));
11171
11172         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11173                                 plaintext_len);
11174         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11175
11176         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
11177
11178         trn_data += plaintext_len;
11179
11180         buf = ut_params->ibuf;
11181
11182         /*
11183          * Loop until no more fragments
11184          */
11185
11186         while (trn_data < tdata->plaintext.len) {
11187                 ++segs;
11188                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
11189                                 (tdata->plaintext.len - trn_data) : fragsz;
11190
11191                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11192                 buf = buf->next;
11193
11194                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
11195                                 rte_pktmbuf_tailroom(buf));
11196
11197                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
11198                                 to_trn);
11199
11200                 memcpy(plaintext, tdata->plaintext.data + trn_data,
11201                                 to_trn);
11202                 trn_data += to_trn;
11203                 if (trn_data  == tdata->plaintext.len)
11204                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
11205                                         tdata->gmac_tag.len);
11206         }
11207         ut_params->ibuf->nb_segs = segs;
11208
11209         /*
11210          * Place digest at the end of the last buffer
11211          */
11212         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
11213
11214         if (!digest_mem) {
11215                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11216                                 + tdata->gmac_tag.len);
11217                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
11218                                 tdata->plaintext.len);
11219         }
11220
11221         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
11222                         tdata, digest_mem, digest_phys);
11223
11224         if (retval < 0)
11225                 return retval;
11226
11227         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11228
11229         ut_params->op->sym->m_src = ut_params->ibuf;
11230
11231         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11232                 return -ENOTSUP;
11233
11234         TEST_ASSERT_NOT_NULL(
11235                 process_crypto_request(ts_params->valid_devs[0],
11236                 ut_params->op), "failed to process sym crypto op");
11237
11238         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11239                         "crypto op processing failed");
11240
11241         auth_tag = digest_mem;
11242         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
11243         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11244                         auth_tag,
11245                         tdata->gmac_tag.data,
11246                         tdata->gmac_tag.len,
11247                         "GMAC Generated auth tag not as expected");
11248
11249         return 0;
11250 }
11251
11252 /* Segment size not multiple of block size (16B) */
11253 static int
11254 test_AES_GMAC_authentication_SGL_40B(void)
11255 {
11256         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
11257 }
11258
11259 static int
11260 test_AES_GMAC_authentication_SGL_80B(void)
11261 {
11262         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
11263 }
11264
11265 static int
11266 test_AES_GMAC_authentication_SGL_2048B(void)
11267 {
11268         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
11269 }
11270
11271 /* Segment size not multiple of block size (16B) */
11272 static int
11273 test_AES_GMAC_authentication_SGL_2047B(void)
11274 {
11275         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
11276 }
11277
11278 struct test_crypto_vector {
11279         enum rte_crypto_cipher_algorithm crypto_algo;
11280         unsigned int cipher_offset;
11281         unsigned int cipher_len;
11282
11283         struct {
11284                 uint8_t data[64];
11285                 unsigned int len;
11286         } cipher_key;
11287
11288         struct {
11289                 uint8_t data[64];
11290                 unsigned int len;
11291         } iv;
11292
11293         struct {
11294                 const uint8_t *data;
11295                 unsigned int len;
11296         } plaintext;
11297
11298         struct {
11299                 const uint8_t *data;
11300                 unsigned int len;
11301         } ciphertext;
11302
11303         enum rte_crypto_auth_algorithm auth_algo;
11304         unsigned int auth_offset;
11305
11306         struct {
11307                 uint8_t data[128];
11308                 unsigned int len;
11309         } auth_key;
11310
11311         struct {
11312                 const uint8_t *data;
11313                 unsigned int len;
11314         } aad;
11315
11316         struct {
11317                 uint8_t data[128];
11318                 unsigned int len;
11319         } digest;
11320 };
11321
11322 static const struct test_crypto_vector
11323 hmac_sha1_test_crypto_vector = {
11324         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11325         .plaintext = {
11326                 .data = plaintext_hash,
11327                 .len = 512
11328         },
11329         .auth_key = {
11330                 .data = {
11331                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11332                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11333                         0xDE, 0xF4, 0xDE, 0xAD
11334                 },
11335                 .len = 20
11336         },
11337         .digest = {
11338                 .data = {
11339                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
11340                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
11341                         0x3F, 0x91, 0x64, 0x59
11342                 },
11343                 .len = 20
11344         }
11345 };
11346
11347 static const struct test_crypto_vector
11348 aes128_gmac_test_vector = {
11349         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
11350         .plaintext = {
11351                 .data = plaintext_hash,
11352                 .len = 512
11353         },
11354         .iv = {
11355                 .data = {
11356                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11357                         0x08, 0x09, 0x0A, 0x0B
11358                 },
11359                 .len = 12
11360         },
11361         .auth_key = {
11362                 .data = {
11363                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11364                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
11365                 },
11366                 .len = 16
11367         },
11368         .digest = {
11369                 .data = {
11370                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
11371                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
11372                 },
11373                 .len = 16
11374         }
11375 };
11376
11377 static const struct test_crypto_vector
11378 aes128cbc_hmac_sha1_test_vector = {
11379         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11380         .cipher_offset = 0,
11381         .cipher_len = 512,
11382         .cipher_key = {
11383                 .data = {
11384                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11385                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11386                 },
11387                 .len = 16
11388         },
11389         .iv = {
11390                 .data = {
11391                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11392                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11393                 },
11394                 .len = 16
11395         },
11396         .plaintext = {
11397                 .data = plaintext_hash,
11398                 .len = 512
11399         },
11400         .ciphertext = {
11401                 .data = ciphertext512_aes128cbc,
11402                 .len = 512
11403         },
11404         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11405         .auth_offset = 0,
11406         .auth_key = {
11407                 .data = {
11408                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11409                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11410                         0xDE, 0xF4, 0xDE, 0xAD
11411                 },
11412                 .len = 20
11413         },
11414         .digest = {
11415                 .data = {
11416                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
11417                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
11418                         0x18, 0x8C, 0x1D, 0x32
11419                 },
11420                 .len = 20
11421         }
11422 };
11423
11424 static const struct test_crypto_vector
11425 aes128cbc_hmac_sha1_aad_test_vector = {
11426         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
11427         .cipher_offset = 8,
11428         .cipher_len = 496,
11429         .cipher_key = {
11430                 .data = {
11431                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
11432                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
11433                 },
11434                 .len = 16
11435         },
11436         .iv = {
11437                 .data = {
11438                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
11439                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
11440                 },
11441                 .len = 16
11442         },
11443         .plaintext = {
11444                 .data = plaintext_hash,
11445                 .len = 512
11446         },
11447         .ciphertext = {
11448                 .data = ciphertext512_aes128cbc_aad,
11449                 .len = 512
11450         },
11451         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
11452         .auth_offset = 0,
11453         .auth_key = {
11454                 .data = {
11455                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
11456                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
11457                         0xDE, 0xF4, 0xDE, 0xAD
11458                 },
11459                 .len = 20
11460         },
11461         .digest = {
11462                 .data = {
11463                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
11464                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
11465                         0x62, 0x0F, 0xFB, 0x10
11466                 },
11467                 .len = 20
11468         }
11469 };
11470
11471 static void
11472 data_corruption(uint8_t *data)
11473 {
11474         data[0] += 1;
11475 }
11476
11477 static void
11478 tag_corruption(uint8_t *data, unsigned int tag_offset)
11479 {
11480         data[tag_offset] += 1;
11481 }
11482
11483 static int
11484 create_auth_session(struct crypto_unittest_params *ut_params,
11485                 uint8_t dev_id,
11486                 const struct test_crypto_vector *reference,
11487                 enum rte_crypto_auth_operation auth_op)
11488 {
11489         struct crypto_testsuite_params *ts_params = &testsuite_params;
11490         uint8_t auth_key[reference->auth_key.len + 1];
11491
11492         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11493
11494         /* Setup Authentication Parameters */
11495         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11496         ut_params->auth_xform.auth.op = auth_op;
11497         ut_params->auth_xform.next = NULL;
11498         ut_params->auth_xform.auth.algo = reference->auth_algo;
11499         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11500         ut_params->auth_xform.auth.key.data = auth_key;
11501         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11502
11503         /* Create Crypto session*/
11504         ut_params->sess = rte_cryptodev_sym_session_create(
11505                         ts_params->session_mpool);
11506
11507         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11508                                 &ut_params->auth_xform,
11509                                 ts_params->session_priv_mpool);
11510
11511         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11512
11513         return 0;
11514 }
11515
11516 static int
11517 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
11518                 uint8_t dev_id,
11519                 const struct test_crypto_vector *reference,
11520                 enum rte_crypto_auth_operation auth_op,
11521                 enum rte_crypto_cipher_operation cipher_op)
11522 {
11523         struct crypto_testsuite_params *ts_params = &testsuite_params;
11524         uint8_t cipher_key[reference->cipher_key.len + 1];
11525         uint8_t auth_key[reference->auth_key.len + 1];
11526
11527         memcpy(cipher_key, reference->cipher_key.data,
11528                         reference->cipher_key.len);
11529         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
11530
11531         /* Setup Authentication Parameters */
11532         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11533         ut_params->auth_xform.auth.op = auth_op;
11534         ut_params->auth_xform.auth.algo = reference->auth_algo;
11535         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
11536         ut_params->auth_xform.auth.key.data = auth_key;
11537         ut_params->auth_xform.auth.digest_length = reference->digest.len;
11538
11539         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
11540                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
11541                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
11542         } else {
11543                 ut_params->auth_xform.next = &ut_params->cipher_xform;
11544
11545                 /* Setup Cipher Parameters */
11546                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11547                 ut_params->cipher_xform.next = NULL;
11548                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
11549                 ut_params->cipher_xform.cipher.op = cipher_op;
11550                 ut_params->cipher_xform.cipher.key.data = cipher_key;
11551                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
11552                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
11553                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
11554         }
11555
11556         /* Create Crypto session*/
11557         ut_params->sess = rte_cryptodev_sym_session_create(
11558                         ts_params->session_mpool);
11559
11560         rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
11561                                 &ut_params->auth_xform,
11562                                 ts_params->session_priv_mpool);
11563
11564         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11565
11566         return 0;
11567 }
11568
11569 static int
11570 create_auth_operation(struct crypto_testsuite_params *ts_params,
11571                 struct crypto_unittest_params *ut_params,
11572                 const struct test_crypto_vector *reference,
11573                 unsigned int auth_generate)
11574 {
11575         /* Generate Crypto op data structure */
11576         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11577                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11578         TEST_ASSERT_NOT_NULL(ut_params->op,
11579                         "Failed to allocate pktmbuf offload");
11580
11581         /* Set crypto operation data parameters */
11582         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11583
11584         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11585
11586         /* set crypto operation source mbuf */
11587         sym_op->m_src = ut_params->ibuf;
11588
11589         /* digest */
11590         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11591                         ut_params->ibuf, reference->digest.len);
11592
11593         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11594                         "no room to append auth tag");
11595
11596         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11597                         ut_params->ibuf, reference->plaintext.len);
11598
11599         if (auth_generate)
11600                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11601         else
11602                 memcpy(sym_op->auth.digest.data,
11603                                 reference->digest.data,
11604                                 reference->digest.len);
11605
11606         debug_hexdump(stdout, "digest:",
11607                         sym_op->auth.digest.data,
11608                         reference->digest.len);
11609
11610         sym_op->auth.data.length = reference->plaintext.len;
11611         sym_op->auth.data.offset = 0;
11612
11613         return 0;
11614 }
11615
11616 static int
11617 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
11618                 struct crypto_unittest_params *ut_params,
11619                 const struct test_crypto_vector *reference,
11620                 unsigned int auth_generate)
11621 {
11622         /* Generate Crypto op data structure */
11623         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11624                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11625         TEST_ASSERT_NOT_NULL(ut_params->op,
11626                         "Failed to allocate pktmbuf offload");
11627
11628         /* Set crypto operation data parameters */
11629         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11630
11631         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11632
11633         /* set crypto operation source mbuf */
11634         sym_op->m_src = ut_params->ibuf;
11635
11636         /* digest */
11637         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11638                         ut_params->ibuf, reference->digest.len);
11639
11640         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11641                         "no room to append auth tag");
11642
11643         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11644                         ut_params->ibuf, reference->ciphertext.len);
11645
11646         if (auth_generate)
11647                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11648         else
11649                 memcpy(sym_op->auth.digest.data,
11650                                 reference->digest.data,
11651                                 reference->digest.len);
11652
11653         debug_hexdump(stdout, "digest:",
11654                         sym_op->auth.digest.data,
11655                         reference->digest.len);
11656
11657         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11658                         reference->iv.data, reference->iv.len);
11659
11660         sym_op->cipher.data.length = 0;
11661         sym_op->cipher.data.offset = 0;
11662
11663         sym_op->auth.data.length = reference->plaintext.len;
11664         sym_op->auth.data.offset = 0;
11665
11666         return 0;
11667 }
11668
11669 static int
11670 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
11671                 struct crypto_unittest_params *ut_params,
11672                 const struct test_crypto_vector *reference,
11673                 unsigned int auth_generate)
11674 {
11675         /* Generate Crypto op data structure */
11676         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11677                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11678         TEST_ASSERT_NOT_NULL(ut_params->op,
11679                         "Failed to allocate pktmbuf offload");
11680
11681         /* Set crypto operation data parameters */
11682         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11683
11684         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11685
11686         /* set crypto operation source mbuf */
11687         sym_op->m_src = ut_params->ibuf;
11688
11689         /* digest */
11690         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11691                         ut_params->ibuf, reference->digest.len);
11692
11693         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11694                         "no room to append auth tag");
11695
11696         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11697                         ut_params->ibuf, reference->ciphertext.len);
11698
11699         if (auth_generate)
11700                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
11701         else
11702                 memcpy(sym_op->auth.digest.data,
11703                                 reference->digest.data,
11704                                 reference->digest.len);
11705
11706         debug_hexdump(stdout, "digest:",
11707                         sym_op->auth.digest.data,
11708                         reference->digest.len);
11709
11710         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
11711                         reference->iv.data, reference->iv.len);
11712
11713         sym_op->cipher.data.length = reference->cipher_len;
11714         sym_op->cipher.data.offset = reference->cipher_offset;
11715
11716         sym_op->auth.data.length = reference->plaintext.len;
11717         sym_op->auth.data.offset = reference->auth_offset;
11718
11719         return 0;
11720 }
11721
11722 static int
11723 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11724                 struct crypto_unittest_params *ut_params,
11725                 const struct test_crypto_vector *reference)
11726 {
11727         return create_auth_operation(ts_params, ut_params, reference, 0);
11728 }
11729
11730 static int
11731 create_auth_verify_GMAC_operation(
11732                 struct crypto_testsuite_params *ts_params,
11733                 struct crypto_unittest_params *ut_params,
11734                 const struct test_crypto_vector *reference)
11735 {
11736         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
11737 }
11738
11739 static int
11740 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
11741                 struct crypto_unittest_params *ut_params,
11742                 const struct test_crypto_vector *reference)
11743 {
11744         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
11745 }
11746
11747 static int
11748 test_authentication_verify_fail_when_data_corruption(
11749                 struct crypto_testsuite_params *ts_params,
11750                 struct crypto_unittest_params *ut_params,
11751                 const struct test_crypto_vector *reference,
11752                 unsigned int data_corrupted)
11753 {
11754         int retval;
11755
11756         uint8_t *plaintext;
11757         struct rte_cryptodev_info dev_info;
11758
11759         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11760         uint64_t feat_flags = dev_info.feature_flags;
11761
11762         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11763                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11764                 printf("Device doesn't support RAW data-path APIs.\n");
11765                 return -ENOTSUP;
11766         }
11767
11768         /* Verify the capabilities */
11769         struct rte_cryptodev_sym_capability_idx cap_idx;
11770         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11771         cap_idx.algo.auth = reference->auth_algo;
11772         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11773                         &cap_idx) == NULL)
11774                 return -ENOTSUP;
11775
11776
11777         /* Create session */
11778         retval = create_auth_session(ut_params,
11779                         ts_params->valid_devs[0],
11780                         reference,
11781                         RTE_CRYPTO_AUTH_OP_VERIFY);
11782         if (retval < 0)
11783                 return retval;
11784
11785         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11786         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11787                         "Failed to allocate input buffer in mempool");
11788
11789         /* clear mbuf payload */
11790         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11791                         rte_pktmbuf_tailroom(ut_params->ibuf));
11792
11793         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11794                         reference->plaintext.len);
11795         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11796         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11797
11798         debug_hexdump(stdout, "plaintext:", plaintext,
11799                 reference->plaintext.len);
11800
11801         /* Create operation */
11802         retval = create_auth_verify_operation(ts_params, ut_params, reference);
11803
11804         if (retval < 0)
11805                 return retval;
11806
11807         if (data_corrupted)
11808                 data_corruption(plaintext);
11809         else
11810                 tag_corruption(plaintext, reference->plaintext.len);
11811
11812         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11813                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11814                         ut_params->op);
11815                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11816                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11817                         "authentication not failed");
11818         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11819                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11820                                 ut_params->op, 0, 1, 0, 0);
11821         else {
11822                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11823                         ut_params->op);
11824                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11825         }
11826
11827         return 0;
11828 }
11829
11830 static int
11831 test_authentication_verify_GMAC_fail_when_corruption(
11832                 struct crypto_testsuite_params *ts_params,
11833                 struct crypto_unittest_params *ut_params,
11834                 const struct test_crypto_vector *reference,
11835                 unsigned int data_corrupted)
11836 {
11837         int retval;
11838         uint8_t *plaintext;
11839         struct rte_cryptodev_info dev_info;
11840
11841         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11842         uint64_t feat_flags = dev_info.feature_flags;
11843
11844         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11845                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11846                 printf("Device doesn't support RAW data-path APIs.\n");
11847                 return -ENOTSUP;
11848         }
11849
11850         /* Verify the capabilities */
11851         struct rte_cryptodev_sym_capability_idx cap_idx;
11852         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11853         cap_idx.algo.auth = reference->auth_algo;
11854         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11855                         &cap_idx) == NULL)
11856                 return -ENOTSUP;
11857
11858         /* Create session */
11859         retval = create_auth_cipher_session(ut_params,
11860                         ts_params->valid_devs[0],
11861                         reference,
11862                         RTE_CRYPTO_AUTH_OP_VERIFY,
11863                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11864         if (retval < 0)
11865                 return retval;
11866
11867         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11868         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11869                         "Failed to allocate input buffer in mempool");
11870
11871         /* clear mbuf payload */
11872         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11873                         rte_pktmbuf_tailroom(ut_params->ibuf));
11874
11875         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11876                         reference->plaintext.len);
11877         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
11878         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
11879
11880         debug_hexdump(stdout, "plaintext:", plaintext,
11881                 reference->plaintext.len);
11882
11883         /* Create operation */
11884         retval = create_auth_verify_GMAC_operation(ts_params,
11885                         ut_params,
11886                         reference);
11887
11888         if (retval < 0)
11889                 return retval;
11890
11891         if (data_corrupted)
11892                 data_corruption(plaintext);
11893         else
11894                 tag_corruption(plaintext, reference->aad.len);
11895
11896         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11897                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11898                         ut_params->op);
11899                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11900                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11901                         "authentication not failed");
11902         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11903                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11904                                 ut_params->op, 0, 1, 0, 0);
11905         else {
11906                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11907                         ut_params->op);
11908                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11909         }
11910
11911         return 0;
11912 }
11913
11914 static int
11915 test_authenticated_decryption_fail_when_corruption(
11916                 struct crypto_testsuite_params *ts_params,
11917                 struct crypto_unittest_params *ut_params,
11918                 const struct test_crypto_vector *reference,
11919                 unsigned int data_corrupted)
11920 {
11921         int retval;
11922
11923         uint8_t *ciphertext;
11924         struct rte_cryptodev_info dev_info;
11925
11926         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11927         uint64_t feat_flags = dev_info.feature_flags;
11928
11929         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11930                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11931                 printf("Device doesn't support RAW data-path APIs.\n");
11932                 return -ENOTSUP;
11933         }
11934
11935         /* Verify the capabilities */
11936         struct rte_cryptodev_sym_capability_idx cap_idx;
11937         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11938         cap_idx.algo.auth = reference->auth_algo;
11939         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11940                         &cap_idx) == NULL)
11941                 return -ENOTSUP;
11942         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11943         cap_idx.algo.cipher = reference->crypto_algo;
11944         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11945                         &cap_idx) == NULL)
11946                 return -ENOTSUP;
11947
11948         /* Create session */
11949         retval = create_auth_cipher_session(ut_params,
11950                         ts_params->valid_devs[0],
11951                         reference,
11952                         RTE_CRYPTO_AUTH_OP_VERIFY,
11953                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
11954         if (retval < 0)
11955                 return retval;
11956
11957         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11958         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
11959                         "Failed to allocate input buffer in mempool");
11960
11961         /* clear mbuf payload */
11962         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11963                         rte_pktmbuf_tailroom(ut_params->ibuf));
11964
11965         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11966                         reference->ciphertext.len);
11967         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
11968         memcpy(ciphertext, reference->ciphertext.data,
11969                         reference->ciphertext.len);
11970
11971         /* Create operation */
11972         retval = create_cipher_auth_verify_operation(ts_params,
11973                         ut_params,
11974                         reference);
11975
11976         if (retval < 0)
11977                 return retval;
11978
11979         if (data_corrupted)
11980                 data_corruption(ciphertext);
11981         else
11982                 tag_corruption(ciphertext, reference->ciphertext.len);
11983
11984         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
11985                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11986                         ut_params->op);
11987                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
11988                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11989                         "authentication not failed");
11990         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11991                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11992                                 ut_params->op, 1, 1, 0, 0);
11993         else {
11994                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
11995                         ut_params->op);
11996                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
11997         }
11998
11999         return 0;
12000 }
12001
12002 static int
12003 test_authenticated_encryt_with_esn(
12004                 struct crypto_testsuite_params *ts_params,
12005                 struct crypto_unittest_params *ut_params,
12006                 const struct test_crypto_vector *reference)
12007 {
12008         int retval;
12009
12010         uint8_t *authciphertext, *plaintext, *auth_tag;
12011         uint16_t plaintext_pad_len;
12012         uint8_t cipher_key[reference->cipher_key.len + 1];
12013         uint8_t auth_key[reference->auth_key.len + 1];
12014         struct rte_cryptodev_info dev_info;
12015
12016         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12017         uint64_t feat_flags = dev_info.feature_flags;
12018
12019         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12020                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12021                 printf("Device doesn't support RAW data-path APIs.\n");
12022                 return -ENOTSUP;
12023         }
12024
12025         /* Verify the capabilities */
12026         struct rte_cryptodev_sym_capability_idx cap_idx;
12027         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12028         cap_idx.algo.auth = reference->auth_algo;
12029         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12030                         &cap_idx) == NULL)
12031                 return -ENOTSUP;
12032         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12033         cap_idx.algo.cipher = reference->crypto_algo;
12034         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12035                         &cap_idx) == NULL)
12036                 return -ENOTSUP;
12037
12038         /* Create session */
12039         memcpy(cipher_key, reference->cipher_key.data,
12040                         reference->cipher_key.len);
12041         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12042
12043         /* Setup Cipher Parameters */
12044         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12045         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12046         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12047         ut_params->cipher_xform.cipher.key.data = cipher_key;
12048         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12049         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12050         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12051
12052         ut_params->cipher_xform.next = &ut_params->auth_xform;
12053
12054         /* Setup Authentication Parameters */
12055         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12056         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12057         ut_params->auth_xform.auth.algo = reference->auth_algo;
12058         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12059         ut_params->auth_xform.auth.key.data = auth_key;
12060         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12061         ut_params->auth_xform.next = NULL;
12062
12063         /* Create Crypto session*/
12064         ut_params->sess = rte_cryptodev_sym_session_create(
12065                         ts_params->session_mpool);
12066
12067         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12068                                 ut_params->sess,
12069                                 &ut_params->cipher_xform,
12070                                 ts_params->session_priv_mpool);
12071
12072         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12073
12074         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12075         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12076                         "Failed to allocate input buffer in mempool");
12077
12078         /* clear mbuf payload */
12079         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12080                         rte_pktmbuf_tailroom(ut_params->ibuf));
12081
12082         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12083                         reference->plaintext.len);
12084         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12085         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
12086
12087         /* Create operation */
12088         retval = create_cipher_auth_operation(ts_params,
12089                         ut_params,
12090                         reference, 0);
12091
12092         if (retval < 0)
12093                 return retval;
12094
12095         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12096                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12097                         ut_params->op);
12098         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12099                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12100                                 ut_params->op, 1, 1, 0, 0);
12101         else
12102                 ut_params->op = process_crypto_request(
12103                         ts_params->valid_devs[0], ut_params->op);
12104
12105         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
12106
12107         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12108                         "crypto op processing failed");
12109
12110         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
12111
12112         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
12113                         ut_params->op->sym->auth.data.offset);
12114         auth_tag = authciphertext + plaintext_pad_len;
12115         debug_hexdump(stdout, "ciphertext:", authciphertext,
12116                         reference->ciphertext.len);
12117         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
12118
12119         /* Validate obuf */
12120         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12121                         authciphertext,
12122                         reference->ciphertext.data,
12123                         reference->ciphertext.len,
12124                         "Ciphertext data not as expected");
12125
12126         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12127                         auth_tag,
12128                         reference->digest.data,
12129                         reference->digest.len,
12130                         "Generated digest not as expected");
12131
12132         return TEST_SUCCESS;
12133
12134 }
12135
12136 static int
12137 test_authenticated_decrypt_with_esn(
12138                 struct crypto_testsuite_params *ts_params,
12139                 struct crypto_unittest_params *ut_params,
12140                 const struct test_crypto_vector *reference)
12141 {
12142         int retval;
12143
12144         uint8_t *ciphertext;
12145         uint8_t cipher_key[reference->cipher_key.len + 1];
12146         uint8_t auth_key[reference->auth_key.len + 1];
12147         struct rte_cryptodev_info dev_info;
12148
12149         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12150         uint64_t feat_flags = dev_info.feature_flags;
12151
12152         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12153                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12154                 printf("Device doesn't support RAW data-path APIs.\n");
12155                 return -ENOTSUP;
12156         }
12157
12158         /* Verify the capabilities */
12159         struct rte_cryptodev_sym_capability_idx cap_idx;
12160         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12161         cap_idx.algo.auth = reference->auth_algo;
12162         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12163                         &cap_idx) == NULL)
12164                 return -ENOTSUP;
12165         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12166         cap_idx.algo.cipher = reference->crypto_algo;
12167         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12168                         &cap_idx) == NULL)
12169                 return -ENOTSUP;
12170
12171         /* Create session */
12172         memcpy(cipher_key, reference->cipher_key.data,
12173                         reference->cipher_key.len);
12174         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12175
12176         /* Setup Authentication Parameters */
12177         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12178         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
12179         ut_params->auth_xform.auth.algo = reference->auth_algo;
12180         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12181         ut_params->auth_xform.auth.key.data = auth_key;
12182         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12183         ut_params->auth_xform.next = &ut_params->cipher_xform;
12184
12185         /* Setup Cipher Parameters */
12186         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12187         ut_params->cipher_xform.next = NULL;
12188         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12189         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
12190         ut_params->cipher_xform.cipher.key.data = cipher_key;
12191         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12192         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12193         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12194
12195         /* Create Crypto session*/
12196         ut_params->sess = rte_cryptodev_sym_session_create(
12197                         ts_params->session_mpool);
12198
12199         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12200                                 ut_params->sess,
12201                                 &ut_params->auth_xform,
12202                                 ts_params->session_priv_mpool);
12203
12204         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12205
12206         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12207         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12208                         "Failed to allocate input buffer in mempool");
12209
12210         /* clear mbuf payload */
12211         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12212                         rte_pktmbuf_tailroom(ut_params->ibuf));
12213
12214         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12215                         reference->ciphertext.len);
12216         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
12217         memcpy(ciphertext, reference->ciphertext.data,
12218                         reference->ciphertext.len);
12219
12220         /* Create operation */
12221         retval = create_cipher_auth_verify_operation(ts_params,
12222                         ut_params,
12223                         reference);
12224
12225         if (retval < 0)
12226                 return retval;
12227
12228         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12229                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12230                         ut_params->op);
12231         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12232                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12233                                 ut_params->op, 1, 1, 0, 0);
12234         else
12235                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
12236                         ut_params->op);
12237
12238         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
12239         TEST_ASSERT_EQUAL(ut_params->op->status,
12240                         RTE_CRYPTO_OP_STATUS_SUCCESS,
12241                         "crypto op processing passed");
12242
12243         ut_params->obuf = ut_params->op->sym->m_src;
12244         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
12245
12246         return 0;
12247 }
12248
12249 static int
12250 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
12251                 const struct aead_test_data *tdata,
12252                 void *digest_mem, uint64_t digest_phys)
12253 {
12254         struct crypto_testsuite_params *ts_params = &testsuite_params;
12255         struct crypto_unittest_params *ut_params = &unittest_params;
12256
12257         const unsigned int auth_tag_len = tdata->auth_tag.len;
12258         const unsigned int iv_len = tdata->iv.len;
12259         unsigned int aad_len = tdata->aad.len;
12260         unsigned int aad_len_pad = 0;
12261
12262         /* Generate Crypto op data structure */
12263         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12264                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12265         TEST_ASSERT_NOT_NULL(ut_params->op,
12266                 "Failed to allocate symmetric crypto operation struct");
12267
12268         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12269
12270         sym_op->aead.digest.data = digest_mem;
12271
12272         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
12273                         "no room to append digest");
12274
12275         sym_op->aead.digest.phys_addr = digest_phys;
12276
12277         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
12278                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
12279                                 auth_tag_len);
12280                 debug_hexdump(stdout, "digest:",
12281                                 sym_op->aead.digest.data,
12282                                 auth_tag_len);
12283         }
12284
12285         /* Append aad data */
12286         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
12287                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12288                                 uint8_t *, IV_OFFSET);
12289
12290                 /* Copy IV 1 byte after the IV pointer, according to the API */
12291                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
12292
12293                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
12294
12295                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12296                                 ut_params->ibuf, aad_len);
12297                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12298                                 "no room to prepend aad");
12299                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12300                                 ut_params->ibuf);
12301
12302                 memset(sym_op->aead.aad.data, 0, aad_len);
12303                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
12304                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12305
12306                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12307                 debug_hexdump(stdout, "aad:",
12308                                 sym_op->aead.aad.data, aad_len);
12309         } else {
12310                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12311                                 uint8_t *, IV_OFFSET);
12312
12313                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
12314
12315                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
12316
12317                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
12318                                 ut_params->ibuf, aad_len_pad);
12319                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
12320                                 "no room to prepend aad");
12321                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
12322                                 ut_params->ibuf);
12323
12324                 memset(sym_op->aead.aad.data, 0, aad_len);
12325                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
12326
12327                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
12328                 debug_hexdump(stdout, "aad:",
12329                                 sym_op->aead.aad.data, aad_len);
12330         }
12331
12332         sym_op->aead.data.length = tdata->plaintext.len;
12333         sym_op->aead.data.offset = aad_len_pad;
12334
12335         return 0;
12336 }
12337
12338 #define SGL_MAX_NO      16
12339
12340 static int
12341 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
12342                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
12343 {
12344         struct crypto_testsuite_params *ts_params = &testsuite_params;
12345         struct crypto_unittest_params *ut_params = &unittest_params;
12346         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
12347         int retval;
12348         int to_trn = 0;
12349         int to_trn_tbl[SGL_MAX_NO];
12350         int segs = 1;
12351         unsigned int trn_data = 0;
12352         uint8_t *plaintext, *ciphertext, *auth_tag;
12353         struct rte_cryptodev_info dev_info;
12354
12355         /* Verify the capabilities */
12356         struct rte_cryptodev_sym_capability_idx cap_idx;
12357         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
12358         cap_idx.algo.aead = tdata->algo;
12359         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12360                         &cap_idx) == NULL)
12361                 return -ENOTSUP;
12362
12363         /* OOP not supported with CPU crypto */
12364         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12365                 return -ENOTSUP;
12366
12367         /* Detailed check for the particular SGL support flag */
12368         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12369         if (!oop) {
12370                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12371                 if (sgl_in && (!(dev_info.feature_flags &
12372                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
12373                         return -ENOTSUP;
12374
12375                 uint64_t feat_flags = dev_info.feature_flags;
12376
12377                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12378                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12379                         printf("Device doesn't support RAW data-path APIs.\n");
12380                         return -ENOTSUP;
12381                 }
12382         } else {
12383                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
12384                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
12385                                 tdata->plaintext.len;
12386                 /* Raw data path API does not support OOP */
12387                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12388                         return -ENOTSUP;
12389                 if (sgl_in && !sgl_out) {
12390                         if (!(dev_info.feature_flags &
12391                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
12392                                 return -ENOTSUP;
12393                 } else if (!sgl_in && sgl_out) {
12394                         if (!(dev_info.feature_flags &
12395                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
12396                                 return -ENOTSUP;
12397                 } else if (sgl_in && sgl_out) {
12398                         if (!(dev_info.feature_flags &
12399                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
12400                                 return -ENOTSUP;
12401                 }
12402         }
12403
12404         if (fragsz > tdata->plaintext.len)
12405                 fragsz = tdata->plaintext.len;
12406
12407         uint16_t plaintext_len = fragsz;
12408         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
12409
12410         if (fragsz_oop > tdata->plaintext.len)
12411                 frag_size_oop = tdata->plaintext.len;
12412
12413         int ecx = 0;
12414         void *digest_mem = NULL;
12415
12416         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
12417
12418         if (tdata->plaintext.len % fragsz != 0) {
12419                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
12420                         return 1;
12421         }       else {
12422                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
12423                         return 1;
12424         }
12425
12426         /*
12427          * For out-op-place we need to alloc another mbuf
12428          */
12429         if (oop) {
12430                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12431                 rte_pktmbuf_append(ut_params->obuf,
12432                                 frag_size_oop + prepend_len);
12433                 buf_oop = ut_params->obuf;
12434         }
12435
12436         /* Create AEAD session */
12437         retval = create_aead_session(ts_params->valid_devs[0],
12438                         tdata->algo,
12439                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
12440                         tdata->key.data, tdata->key.len,
12441                         tdata->aad.len, tdata->auth_tag.len,
12442                         tdata->iv.len);
12443         if (retval < 0)
12444                 return retval;
12445
12446         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12447
12448         /* clear mbuf payload */
12449         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12450                         rte_pktmbuf_tailroom(ut_params->ibuf));
12451
12452         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12453                         plaintext_len);
12454
12455         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12456
12457         trn_data += plaintext_len;
12458
12459         buf = ut_params->ibuf;
12460
12461         /*
12462          * Loop until no more fragments
12463          */
12464
12465         while (trn_data < tdata->plaintext.len) {
12466                 ++segs;
12467                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12468                                 (tdata->plaintext.len - trn_data) : fragsz;
12469
12470                 to_trn_tbl[ecx++] = to_trn;
12471
12472                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12473                 buf = buf->next;
12474
12475                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12476                                 rte_pktmbuf_tailroom(buf));
12477
12478                 /* OOP */
12479                 if (oop && !fragsz_oop) {
12480                         buf_last_oop = buf_oop->next =
12481                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12482                         buf_oop = buf_oop->next;
12483                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12484                                         0, rte_pktmbuf_tailroom(buf_oop));
12485                         rte_pktmbuf_append(buf_oop, to_trn);
12486                 }
12487
12488                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12489                                 to_trn);
12490
12491                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12492                                 to_trn);
12493                 trn_data += to_trn;
12494                 if (trn_data  == tdata->plaintext.len) {
12495                         if (oop) {
12496                                 if (!fragsz_oop)
12497                                         digest_mem = rte_pktmbuf_append(buf_oop,
12498                                                 tdata->auth_tag.len);
12499                         } else
12500                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12501                                         tdata->auth_tag.len);
12502                 }
12503         }
12504
12505         uint64_t digest_phys = 0;
12506
12507         ut_params->ibuf->nb_segs = segs;
12508
12509         segs = 1;
12510         if (fragsz_oop && oop) {
12511                 to_trn = 0;
12512                 ecx = 0;
12513
12514                 if (frag_size_oop == tdata->plaintext.len) {
12515                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
12516                                 tdata->auth_tag.len);
12517
12518                         digest_phys = rte_pktmbuf_iova_offset(
12519                                         ut_params->obuf,
12520                                         tdata->plaintext.len + prepend_len);
12521                 }
12522
12523                 trn_data = frag_size_oop;
12524                 while (trn_data < tdata->plaintext.len) {
12525                         ++segs;
12526                         to_trn =
12527                                 (tdata->plaintext.len - trn_data <
12528                                                 frag_size_oop) ?
12529                                 (tdata->plaintext.len - trn_data) :
12530                                                 frag_size_oop;
12531
12532                         to_trn_tbl[ecx++] = to_trn;
12533
12534                         buf_last_oop = buf_oop->next =
12535                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
12536                         buf_oop = buf_oop->next;
12537                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
12538                                         0, rte_pktmbuf_tailroom(buf_oop));
12539                         rte_pktmbuf_append(buf_oop, to_trn);
12540
12541                         trn_data += to_trn;
12542
12543                         if (trn_data  == tdata->plaintext.len) {
12544                                 digest_mem = rte_pktmbuf_append(buf_oop,
12545                                         tdata->auth_tag.len);
12546                         }
12547                 }
12548
12549                 ut_params->obuf->nb_segs = segs;
12550         }
12551
12552         /*
12553          * Place digest at the end of the last buffer
12554          */
12555         if (!digest_phys)
12556                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12557         if (oop && buf_last_oop)
12558                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
12559
12560         if (!digest_mem && !oop) {
12561                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12562                                 + tdata->auth_tag.len);
12563                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12564                                 tdata->plaintext.len);
12565         }
12566
12567         /* Create AEAD operation */
12568         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
12569                         tdata, digest_mem, digest_phys);
12570
12571         if (retval < 0)
12572                 return retval;
12573
12574         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12575
12576         ut_params->op->sym->m_src = ut_params->ibuf;
12577         if (oop)
12578                 ut_params->op->sym->m_dst = ut_params->obuf;
12579
12580         /* Process crypto operation */
12581         if (oop == IN_PLACE &&
12582                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12583                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
12584         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12585                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12586                                 ut_params->op, 0, 0, 0, 0);
12587         else
12588                 TEST_ASSERT_NOT_NULL(
12589                         process_crypto_request(ts_params->valid_devs[0],
12590                         ut_params->op), "failed to process sym crypto op");
12591
12592         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12593                         "crypto op processing failed");
12594
12595
12596         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
12597                         uint8_t *, prepend_len);
12598         if (oop) {
12599                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12600                                 uint8_t *, prepend_len);
12601         }
12602
12603         if (fragsz_oop)
12604                 fragsz = fragsz_oop;
12605
12606         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12607                         ciphertext,
12608                         tdata->ciphertext.data,
12609                         fragsz,
12610                         "Ciphertext data not as expected");
12611
12612         buf = ut_params->op->sym->m_src->next;
12613         if (oop)
12614                 buf = ut_params->op->sym->m_dst->next;
12615
12616         unsigned int off = fragsz;
12617
12618         ecx = 0;
12619         while (buf) {
12620                 ciphertext = rte_pktmbuf_mtod(buf,
12621                                 uint8_t *);
12622
12623                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
12624                                 ciphertext,
12625                                 tdata->ciphertext.data + off,
12626                                 to_trn_tbl[ecx],
12627                                 "Ciphertext data not as expected");
12628
12629                 off += to_trn_tbl[ecx++];
12630                 buf = buf->next;
12631         }
12632
12633         auth_tag = digest_mem;
12634         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12635                         auth_tag,
12636                         tdata->auth_tag.data,
12637                         tdata->auth_tag.len,
12638                         "Generated auth tag not as expected");
12639
12640         return 0;
12641 }
12642
12643 static int
12644 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
12645 {
12646         return test_authenticated_encryption_SGL(
12647                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
12648 }
12649
12650 static int
12651 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
12652 {
12653         return test_authenticated_encryption_SGL(
12654                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
12655 }
12656
12657 static int
12658 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
12659 {
12660         return test_authenticated_encryption_SGL(
12661                         &gcm_test_case_8, OUT_OF_PLACE, 400,
12662                         gcm_test_case_8.plaintext.len);
12663 }
12664
12665 static int
12666 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
12667 {
12668         /* This test is not for OPENSSL PMD */
12669         if (gbl_driver_id == rte_cryptodev_driver_id_get(
12670                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
12671                 return -ENOTSUP;
12672
12673         return test_authenticated_encryption_SGL(
12674                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
12675 }
12676
12677 static int
12678 test_authentication_verify_fail_when_data_corrupted(
12679                 struct crypto_testsuite_params *ts_params,
12680                 struct crypto_unittest_params *ut_params,
12681                 const struct test_crypto_vector *reference)
12682 {
12683         return test_authentication_verify_fail_when_data_corruption(
12684                         ts_params, ut_params, reference, 1);
12685 }
12686
12687 static int
12688 test_authentication_verify_fail_when_tag_corrupted(
12689                 struct crypto_testsuite_params *ts_params,
12690                 struct crypto_unittest_params *ut_params,
12691                 const struct test_crypto_vector *reference)
12692 {
12693         return test_authentication_verify_fail_when_data_corruption(
12694                         ts_params, ut_params, reference, 0);
12695 }
12696
12697 static int
12698 test_authentication_verify_GMAC_fail_when_data_corrupted(
12699                 struct crypto_testsuite_params *ts_params,
12700                 struct crypto_unittest_params *ut_params,
12701                 const struct test_crypto_vector *reference)
12702 {
12703         return test_authentication_verify_GMAC_fail_when_corruption(
12704                         ts_params, ut_params, reference, 1);
12705 }
12706
12707 static int
12708 test_authentication_verify_GMAC_fail_when_tag_corrupted(
12709                 struct crypto_testsuite_params *ts_params,
12710                 struct crypto_unittest_params *ut_params,
12711                 const struct test_crypto_vector *reference)
12712 {
12713         return test_authentication_verify_GMAC_fail_when_corruption(
12714                         ts_params, ut_params, reference, 0);
12715 }
12716
12717 static int
12718 test_authenticated_decryption_fail_when_data_corrupted(
12719                 struct crypto_testsuite_params *ts_params,
12720                 struct crypto_unittest_params *ut_params,
12721                 const struct test_crypto_vector *reference)
12722 {
12723         return test_authenticated_decryption_fail_when_corruption(
12724                         ts_params, ut_params, reference, 1);
12725 }
12726
12727 static int
12728 test_authenticated_decryption_fail_when_tag_corrupted(
12729                 struct crypto_testsuite_params *ts_params,
12730                 struct crypto_unittest_params *ut_params,
12731                 const struct test_crypto_vector *reference)
12732 {
12733         return test_authenticated_decryption_fail_when_corruption(
12734                         ts_params, ut_params, reference, 0);
12735 }
12736
12737 static int
12738 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
12739 {
12740         return test_authentication_verify_fail_when_data_corrupted(
12741                         &testsuite_params, &unittest_params,
12742                         &hmac_sha1_test_crypto_vector);
12743 }
12744
12745 static int
12746 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
12747 {
12748         return test_authentication_verify_fail_when_tag_corrupted(
12749                         &testsuite_params, &unittest_params,
12750                         &hmac_sha1_test_crypto_vector);
12751 }
12752
12753 static int
12754 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
12755 {
12756         return test_authentication_verify_GMAC_fail_when_data_corrupted(
12757                         &testsuite_params, &unittest_params,
12758                         &aes128_gmac_test_vector);
12759 }
12760
12761 static int
12762 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
12763 {
12764         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
12765                         &testsuite_params, &unittest_params,
12766                         &aes128_gmac_test_vector);
12767 }
12768
12769 static int
12770 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
12771 {
12772         return test_authenticated_decryption_fail_when_data_corrupted(
12773                         &testsuite_params,
12774                         &unittest_params,
12775                         &aes128cbc_hmac_sha1_test_vector);
12776 }
12777
12778 static int
12779 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
12780 {
12781         return test_authenticated_decryption_fail_when_tag_corrupted(
12782                         &testsuite_params,
12783                         &unittest_params,
12784                         &aes128cbc_hmac_sha1_test_vector);
12785 }
12786
12787 static int
12788 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12789 {
12790         return test_authenticated_encryt_with_esn(
12791                         &testsuite_params,
12792                         &unittest_params,
12793                         &aes128cbc_hmac_sha1_aad_test_vector);
12794 }
12795
12796 static int
12797 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
12798 {
12799         return test_authenticated_decrypt_with_esn(
12800                         &testsuite_params,
12801                         &unittest_params,
12802                         &aes128cbc_hmac_sha1_aad_test_vector);
12803 }
12804
12805 static int
12806 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
12807 {
12808         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
12809 }
12810
12811 static int
12812 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
12813 {
12814         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
12815 }
12816
12817 #ifdef RTE_CRYPTO_SCHEDULER
12818
12819 /* global AESNI worker IDs for the scheduler test */
12820 uint8_t aesni_ids[2];
12821
12822 static int
12823 test_scheduler_attach_slave_op(void)
12824 {
12825         struct crypto_testsuite_params *ts_params = &testsuite_params;
12826         uint8_t sched_id = ts_params->valid_devs[0];
12827         uint32_t nb_devs, i, nb_devs_attached = 0;
12828         int ret;
12829         char vdev_name[32];
12830
12831         /* create 2 AESNI_MB if necessary */
12832         nb_devs = rte_cryptodev_device_count_by_driver(
12833                         rte_cryptodev_driver_id_get(
12834                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
12835         if (nb_devs < 2) {
12836                 for (i = nb_devs; i < 2; i++) {
12837                         snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
12838                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
12839                                         i);
12840                         ret = rte_vdev_init(vdev_name, NULL);
12841
12842                         TEST_ASSERT(ret == 0,
12843                                 "Failed to create instance %u of"
12844                                 " pmd : %s",
12845                                 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12846                 }
12847         }
12848
12849         /* attach 2 AESNI_MB cdevs */
12850         for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2;
12851                         i++) {
12852                 struct rte_cryptodev_info info;
12853                 unsigned int session_size;
12854
12855                 rte_cryptodev_info_get(i, &info);
12856                 if (info.driver_id != rte_cryptodev_driver_id_get(
12857                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
12858                         continue;
12859
12860                 session_size = rte_cryptodev_sym_get_private_session_size(i);
12861                 /*
12862                  * Create the session mempool again, since now there are new devices
12863                  * to use the mempool.
12864                  */
12865                 if (ts_params->session_mpool) {
12866                         rte_mempool_free(ts_params->session_mpool);
12867                         ts_params->session_mpool = NULL;
12868                 }
12869                 if (ts_params->session_priv_mpool) {
12870                         rte_mempool_free(ts_params->session_priv_mpool);
12871                         ts_params->session_priv_mpool = NULL;
12872                 }
12873
12874                 if (info.sym.max_nb_sessions != 0 &&
12875                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
12876                         RTE_LOG(ERR, USER1,
12877                                         "Device does not support "
12878                                         "at least %u sessions\n",
12879                                         MAX_NB_SESSIONS);
12880                         return TEST_FAILED;
12881                 }
12882                 /*
12883                  * Create mempool with maximum number of sessions,
12884                  * to include the session headers
12885                  */
12886                 if (ts_params->session_mpool == NULL) {
12887                         ts_params->session_mpool =
12888                                 rte_cryptodev_sym_session_pool_create(
12889                                                 "test_sess_mp",
12890                                                 MAX_NB_SESSIONS, 0, 0, 0,
12891                                                 SOCKET_ID_ANY);
12892                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
12893                                         "session mempool allocation failed");
12894                 }
12895
12896                 /*
12897                  * Create mempool with maximum number of sessions,
12898                  * to include device specific session private data
12899                  */
12900                 if (ts_params->session_priv_mpool == NULL) {
12901                         ts_params->session_priv_mpool = rte_mempool_create(
12902                                         "test_sess_mp_priv",
12903                                         MAX_NB_SESSIONS,
12904                                         session_size,
12905                                         0, 0, NULL, NULL, NULL,
12906                                         NULL, SOCKET_ID_ANY,
12907                                         0);
12908
12909                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
12910                                         "session mempool allocation failed");
12911                 }
12912
12913                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
12914                 ts_params->qp_conf.mp_session_private =
12915                                 ts_params->session_priv_mpool;
12916
12917                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
12918                                 (uint8_t)i);
12919
12920                 TEST_ASSERT(ret == 0,
12921                         "Failed to attach device %u of pmd : %s", i,
12922                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
12923
12924                 aesni_ids[nb_devs_attached] = (uint8_t)i;
12925
12926                 nb_devs_attached++;
12927         }
12928
12929         return 0;
12930 }
12931
12932 static int
12933 test_scheduler_detach_slave_op(void)
12934 {
12935         struct crypto_testsuite_params *ts_params = &testsuite_params;
12936         uint8_t sched_id = ts_params->valid_devs[0];
12937         uint32_t i;
12938         int ret;
12939
12940         for (i = 0; i < 2; i++) {
12941                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
12942                                 aesni_ids[i]);
12943                 TEST_ASSERT(ret == 0,
12944                         "Failed to detach device %u", aesni_ids[i]);
12945         }
12946
12947         return 0;
12948 }
12949
12950 static int
12951 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
12952 {
12953         struct crypto_testsuite_params *ts_params = &testsuite_params;
12954         uint8_t sched_id = ts_params->valid_devs[0];
12955         /* set mode */
12956         return rte_cryptodev_scheduler_mode_set(sched_id,
12957                 scheduler_mode);
12958 }
12959
12960 static int
12961 test_scheduler_mode_roundrobin_op(void)
12962 {
12963         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
12964                         0, "Failed to set roundrobin mode");
12965         return 0;
12966
12967 }
12968
12969 static int
12970 test_scheduler_mode_multicore_op(void)
12971 {
12972         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
12973                         0, "Failed to set multicore mode");
12974
12975         return 0;
12976 }
12977
12978 static int
12979 test_scheduler_mode_failover_op(void)
12980 {
12981         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
12982                         0, "Failed to set failover mode");
12983
12984         return 0;
12985 }
12986
12987 static int
12988 test_scheduler_mode_pkt_size_distr_op(void)
12989 {
12990         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
12991                         0, "Failed to set pktsize mode");
12992
12993         return 0;
12994 }
12995
12996 static struct unit_test_suite cryptodev_scheduler_testsuite  = {
12997         .suite_name = "Crypto Device Scheduler Unit Test Suite",
12998         .setup = testsuite_setup,
12999         .teardown = testsuite_teardown,
13000         .unit_test_cases = {
13001                 /* Multi Core */
13002                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13003                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
13004                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13005                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13006                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13007                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13008
13009                 /* Round Robin */
13010                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13011                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
13012                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13013                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13014                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13015                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13016
13017                 /* Fail over */
13018                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13019                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
13020                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13021                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13022                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13023                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13024
13025                 /* PKT SIZE */
13026                 TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
13027                 TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
13028                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13029                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13030                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13031                 TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
13032
13033                 TEST_CASES_END() /**< NULL terminate unit test array */
13034         }
13035 };
13036
13037 #endif /* RTE_CRYPTO_SCHEDULER */
13038
13039 static struct unit_test_suite cryptodev_testsuite  = {
13040         .suite_name = "Crypto Unit Test Suite",
13041         .setup = testsuite_setup,
13042         .teardown = testsuite_teardown,
13043         .unit_test_cases = {
13044                 TEST_CASE_ST(ut_setup, ut_teardown,
13045                                 test_device_configure_invalid_dev_id),
13046                 TEST_CASE_ST(ut_setup, ut_teardown,
13047                                 test_queue_pair_descriptor_setup),
13048                 TEST_CASE_ST(ut_setup, ut_teardown,
13049                                 test_device_configure_invalid_queue_pair_ids),
13050
13051                 TEST_CASE_ST(ut_setup, ut_teardown,
13052                                 test_multi_session),
13053                 TEST_CASE_ST(ut_setup, ut_teardown,
13054                                 test_multi_session_random_usage),
13055
13056                 TEST_CASE_ST(ut_setup, ut_teardown,
13057                         test_null_invalid_operation),
13058                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
13059
13060                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13061                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13062                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13063                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13064                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_cipheronly_all),
13065                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_all),
13066                 TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
13067                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13068                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
13069
13070                 /** AES CCM Authenticated Encryption 128 bits key */
13071                 TEST_CASE_ST(ut_setup, ut_teardown,
13072                         test_AES_CCM_authenticated_encryption_test_case_128_1),
13073                 TEST_CASE_ST(ut_setup, ut_teardown,
13074                         test_AES_CCM_authenticated_encryption_test_case_128_2),
13075                 TEST_CASE_ST(ut_setup, ut_teardown,
13076                         test_AES_CCM_authenticated_encryption_test_case_128_3),
13077
13078                 /** AES CCM Authenticated Decryption 128 bits key*/
13079                 TEST_CASE_ST(ut_setup, ut_teardown,
13080                         test_AES_CCM_authenticated_decryption_test_case_128_1),
13081                 TEST_CASE_ST(ut_setup, ut_teardown,
13082                         test_AES_CCM_authenticated_decryption_test_case_128_2),
13083                 TEST_CASE_ST(ut_setup, ut_teardown,
13084                         test_AES_CCM_authenticated_decryption_test_case_128_3),
13085
13086                 /** AES CCM Authenticated Encryption 192 bits key */
13087                 TEST_CASE_ST(ut_setup, ut_teardown,
13088                         test_AES_CCM_authenticated_encryption_test_case_192_1),
13089                 TEST_CASE_ST(ut_setup, ut_teardown,
13090                         test_AES_CCM_authenticated_encryption_test_case_192_2),
13091                 TEST_CASE_ST(ut_setup, ut_teardown,
13092                         test_AES_CCM_authenticated_encryption_test_case_192_3),
13093
13094                 /** AES CCM Authenticated Decryption 192 bits key*/
13095                 TEST_CASE_ST(ut_setup, ut_teardown,
13096                         test_AES_CCM_authenticated_decryption_test_case_192_1),
13097                 TEST_CASE_ST(ut_setup, ut_teardown,
13098                         test_AES_CCM_authenticated_decryption_test_case_192_2),
13099                 TEST_CASE_ST(ut_setup, ut_teardown,
13100                         test_AES_CCM_authenticated_decryption_test_case_192_3),
13101
13102                 /** AES CCM Authenticated Encryption 256 bits key */
13103                 TEST_CASE_ST(ut_setup, ut_teardown,
13104                         test_AES_CCM_authenticated_encryption_test_case_256_1),
13105                 TEST_CASE_ST(ut_setup, ut_teardown,
13106                         test_AES_CCM_authenticated_encryption_test_case_256_2),
13107                 TEST_CASE_ST(ut_setup, ut_teardown,
13108                         test_AES_CCM_authenticated_encryption_test_case_256_3),
13109
13110                 /** AES CCM Authenticated Decryption 256 bits key*/
13111                 TEST_CASE_ST(ut_setup, ut_teardown,
13112                         test_AES_CCM_authenticated_decryption_test_case_256_1),
13113                 TEST_CASE_ST(ut_setup, ut_teardown,
13114                         test_AES_CCM_authenticated_decryption_test_case_256_2),
13115                 TEST_CASE_ST(ut_setup, ut_teardown,
13116                         test_AES_CCM_authenticated_decryption_test_case_256_3),
13117
13118                 /** AES GCM Authenticated Encryption */
13119                 TEST_CASE_ST(ut_setup, ut_teardown,
13120                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
13121                 TEST_CASE_ST(ut_setup, ut_teardown,
13122                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
13123                 TEST_CASE_ST(ut_setup, ut_teardown,
13124                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
13125                 TEST_CASE_ST(ut_setup, ut_teardown,
13126                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
13127                 TEST_CASE_ST(ut_setup, ut_teardown,
13128                         test_AES_GCM_authenticated_encryption_test_case_1),
13129                 TEST_CASE_ST(ut_setup, ut_teardown,
13130                         test_AES_GCM_authenticated_encryption_test_case_2),
13131                 TEST_CASE_ST(ut_setup, ut_teardown,
13132                         test_AES_GCM_authenticated_encryption_test_case_3),
13133                 TEST_CASE_ST(ut_setup, ut_teardown,
13134                         test_AES_GCM_authenticated_encryption_test_case_4),
13135                 TEST_CASE_ST(ut_setup, ut_teardown,
13136                         test_AES_GCM_authenticated_encryption_test_case_5),
13137                 TEST_CASE_ST(ut_setup, ut_teardown,
13138                         test_AES_GCM_authenticated_encryption_test_case_6),
13139                 TEST_CASE_ST(ut_setup, ut_teardown,
13140                         test_AES_GCM_authenticated_encryption_test_case_7),
13141                 TEST_CASE_ST(ut_setup, ut_teardown,
13142                         test_AES_GCM_authenticated_encryption_test_case_8),
13143                 TEST_CASE_ST(ut_setup, ut_teardown,
13144                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
13145
13146                 /** AES GCM Authenticated Decryption */
13147                 TEST_CASE_ST(ut_setup, ut_teardown,
13148                         test_AES_GCM_authenticated_decryption_test_case_1),
13149                 TEST_CASE_ST(ut_setup, ut_teardown,
13150                         test_AES_GCM_authenticated_decryption_test_case_2),
13151                 TEST_CASE_ST(ut_setup, ut_teardown,
13152                         test_AES_GCM_authenticated_decryption_test_case_3),
13153                 TEST_CASE_ST(ut_setup, ut_teardown,
13154                         test_AES_GCM_authenticated_decryption_test_case_4),
13155                 TEST_CASE_ST(ut_setup, ut_teardown,
13156                         test_AES_GCM_authenticated_decryption_test_case_5),
13157                 TEST_CASE_ST(ut_setup, ut_teardown,
13158                         test_AES_GCM_authenticated_decryption_test_case_6),
13159                 TEST_CASE_ST(ut_setup, ut_teardown,
13160                         test_AES_GCM_authenticated_decryption_test_case_7),
13161                 TEST_CASE_ST(ut_setup, ut_teardown,
13162                         test_AES_GCM_authenticated_decryption_test_case_8),
13163                 TEST_CASE_ST(ut_setup, ut_teardown,
13164                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
13165
13166                 /** AES GCM Authenticated Encryption 192 bits key */
13167                 TEST_CASE_ST(ut_setup, ut_teardown,
13168                         test_AES_GCM_auth_encryption_test_case_192_1),
13169                 TEST_CASE_ST(ut_setup, ut_teardown,
13170                         test_AES_GCM_auth_encryption_test_case_192_2),
13171                 TEST_CASE_ST(ut_setup, ut_teardown,
13172                         test_AES_GCM_auth_encryption_test_case_192_3),
13173                 TEST_CASE_ST(ut_setup, ut_teardown,
13174                         test_AES_GCM_auth_encryption_test_case_192_4),
13175                 TEST_CASE_ST(ut_setup, ut_teardown,
13176                         test_AES_GCM_auth_encryption_test_case_192_5),
13177                 TEST_CASE_ST(ut_setup, ut_teardown,
13178                         test_AES_GCM_auth_encryption_test_case_192_6),
13179                 TEST_CASE_ST(ut_setup, ut_teardown,
13180                         test_AES_GCM_auth_encryption_test_case_192_7),
13181
13182                 /** AES GCM Authenticated Decryption 192 bits key */
13183                 TEST_CASE_ST(ut_setup, ut_teardown,
13184                         test_AES_GCM_auth_decryption_test_case_192_1),
13185                 TEST_CASE_ST(ut_setup, ut_teardown,
13186                         test_AES_GCM_auth_decryption_test_case_192_2),
13187                 TEST_CASE_ST(ut_setup, ut_teardown,
13188                         test_AES_GCM_auth_decryption_test_case_192_3),
13189                 TEST_CASE_ST(ut_setup, ut_teardown,
13190                         test_AES_GCM_auth_decryption_test_case_192_4),
13191                 TEST_CASE_ST(ut_setup, ut_teardown,
13192                         test_AES_GCM_auth_decryption_test_case_192_5),
13193                 TEST_CASE_ST(ut_setup, ut_teardown,
13194                         test_AES_GCM_auth_decryption_test_case_192_6),
13195                 TEST_CASE_ST(ut_setup, ut_teardown,
13196                         test_AES_GCM_auth_decryption_test_case_192_7),
13197
13198                 /** AES GCM Authenticated Encryption 256 bits key */
13199                 TEST_CASE_ST(ut_setup, ut_teardown,
13200                         test_AES_GCM_auth_encryption_test_case_256_1),
13201                 TEST_CASE_ST(ut_setup, ut_teardown,
13202                         test_AES_GCM_auth_encryption_test_case_256_2),
13203                 TEST_CASE_ST(ut_setup, ut_teardown,
13204                         test_AES_GCM_auth_encryption_test_case_256_3),
13205                 TEST_CASE_ST(ut_setup, ut_teardown,
13206                         test_AES_GCM_auth_encryption_test_case_256_4),
13207                 TEST_CASE_ST(ut_setup, ut_teardown,
13208                         test_AES_GCM_auth_encryption_test_case_256_5),
13209                 TEST_CASE_ST(ut_setup, ut_teardown,
13210                         test_AES_GCM_auth_encryption_test_case_256_6),
13211                 TEST_CASE_ST(ut_setup, ut_teardown,
13212                         test_AES_GCM_auth_encryption_test_case_256_7),
13213
13214                 /** AES GCM Authenticated Decryption 256 bits key */
13215                 TEST_CASE_ST(ut_setup, ut_teardown,
13216                         test_AES_GCM_auth_decryption_test_case_256_1),
13217                 TEST_CASE_ST(ut_setup, ut_teardown,
13218                         test_AES_GCM_auth_decryption_test_case_256_2),
13219                 TEST_CASE_ST(ut_setup, ut_teardown,
13220                         test_AES_GCM_auth_decryption_test_case_256_3),
13221                 TEST_CASE_ST(ut_setup, ut_teardown,
13222                         test_AES_GCM_auth_decryption_test_case_256_4),
13223                 TEST_CASE_ST(ut_setup, ut_teardown,
13224                         test_AES_GCM_auth_decryption_test_case_256_5),
13225                 TEST_CASE_ST(ut_setup, ut_teardown,
13226                         test_AES_GCM_auth_decryption_test_case_256_6),
13227                 TEST_CASE_ST(ut_setup, ut_teardown,
13228                         test_AES_GCM_auth_decryption_test_case_256_7),
13229
13230                 /** AES GCM Authenticated Encryption big aad size */
13231                 TEST_CASE_ST(ut_setup, ut_teardown,
13232                         test_AES_GCM_auth_encryption_test_case_aad_1),
13233                 TEST_CASE_ST(ut_setup, ut_teardown,
13234                         test_AES_GCM_auth_encryption_test_case_aad_2),
13235
13236                 /** AES GCM Authenticated Decryption big aad size */
13237                 TEST_CASE_ST(ut_setup, ut_teardown,
13238                         test_AES_GCM_auth_decryption_test_case_aad_1),
13239                 TEST_CASE_ST(ut_setup, ut_teardown,
13240                         test_AES_GCM_auth_decryption_test_case_aad_2),
13241
13242                 /** Out of place tests */
13243                 TEST_CASE_ST(ut_setup, ut_teardown,
13244                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
13245                 TEST_CASE_ST(ut_setup, ut_teardown,
13246                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
13247
13248                 /** Session-less tests */
13249                 TEST_CASE_ST(ut_setup, ut_teardown,
13250                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
13251                 TEST_CASE_ST(ut_setup, ut_teardown,
13252                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
13253
13254                 /** AES GMAC Authentication */
13255                 TEST_CASE_ST(ut_setup, ut_teardown,
13256                         test_AES_GMAC_authentication_test_case_1),
13257                 TEST_CASE_ST(ut_setup, ut_teardown,
13258                         test_AES_GMAC_authentication_verify_test_case_1),
13259                 TEST_CASE_ST(ut_setup, ut_teardown,
13260                         test_AES_GMAC_authentication_test_case_2),
13261                 TEST_CASE_ST(ut_setup, ut_teardown,
13262                         test_AES_GMAC_authentication_verify_test_case_2),
13263                 TEST_CASE_ST(ut_setup, ut_teardown,
13264                         test_AES_GMAC_authentication_test_case_3),
13265                 TEST_CASE_ST(ut_setup, ut_teardown,
13266                         test_AES_GMAC_authentication_verify_test_case_3),
13267                 TEST_CASE_ST(ut_setup, ut_teardown,
13268                         test_AES_GMAC_authentication_test_case_4),
13269                 TEST_CASE_ST(ut_setup, ut_teardown,
13270                         test_AES_GMAC_authentication_verify_test_case_4),
13271                 TEST_CASE_ST(ut_setup, ut_teardown,
13272                         test_AES_GMAC_authentication_SGL_40B),
13273                 TEST_CASE_ST(ut_setup, ut_teardown,
13274                         test_AES_GMAC_authentication_SGL_80B),
13275                 TEST_CASE_ST(ut_setup, ut_teardown,
13276                         test_AES_GMAC_authentication_SGL_2048B),
13277                 TEST_CASE_ST(ut_setup, ut_teardown,
13278                         test_AES_GMAC_authentication_SGL_2047B),
13279
13280                 /** Chacha20-Poly1305 */
13281                 TEST_CASE_ST(ut_setup, ut_teardown,
13282                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
13283                 TEST_CASE_ST(ut_setup, ut_teardown,
13284                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
13285                 /** SNOW 3G encrypt only (UEA2) */
13286                 TEST_CASE_ST(ut_setup, ut_teardown,
13287                         test_snow3g_encryption_test_case_1),
13288                 TEST_CASE_ST(ut_setup, ut_teardown,
13289                         test_snow3g_encryption_test_case_2),
13290                 TEST_CASE_ST(ut_setup, ut_teardown,
13291                         test_snow3g_encryption_test_case_3),
13292                 TEST_CASE_ST(ut_setup, ut_teardown,
13293                         test_snow3g_encryption_test_case_4),
13294                 TEST_CASE_ST(ut_setup, ut_teardown,
13295                         test_snow3g_encryption_test_case_5),
13296
13297                 TEST_CASE_ST(ut_setup, ut_teardown,
13298                         test_snow3g_encryption_test_case_1_oop),
13299                 TEST_CASE_ST(ut_setup, ut_teardown,
13300                         test_snow3g_encryption_test_case_1_oop_sgl),
13301                 TEST_CASE_ST(ut_setup, ut_teardown,
13302                         test_snow3g_encryption_test_case_1_offset_oop),
13303                 TEST_CASE_ST(ut_setup, ut_teardown,
13304                         test_snow3g_decryption_test_case_1_oop),
13305
13306                 /** SNOW 3G generate auth, then encrypt (UEA2) */
13307                 TEST_CASE_ST(ut_setup, ut_teardown,
13308                         test_snow3g_auth_cipher_test_case_1),
13309                 TEST_CASE_ST(ut_setup, ut_teardown,
13310                         test_snow3g_auth_cipher_test_case_2),
13311                 TEST_CASE_ST(ut_setup, ut_teardown,
13312                         test_snow3g_auth_cipher_test_case_2_oop),
13313                 TEST_CASE_ST(ut_setup, ut_teardown,
13314                         test_snow3g_auth_cipher_part_digest_enc),
13315                 TEST_CASE_ST(ut_setup, ut_teardown,
13316                         test_snow3g_auth_cipher_part_digest_enc_oop),
13317                 TEST_CASE_ST(ut_setup, ut_teardown,
13318                         test_snow3g_auth_cipher_test_case_3_sgl),
13319                 TEST_CASE_ST(ut_setup, ut_teardown,
13320                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
13321                 TEST_CASE_ST(ut_setup, ut_teardown,
13322                         test_snow3g_auth_cipher_part_digest_enc_sgl),
13323                 TEST_CASE_ST(ut_setup, ut_teardown,
13324                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
13325
13326                 /** SNOW 3G decrypt (UEA2), then verify auth */
13327                 TEST_CASE_ST(ut_setup, ut_teardown,
13328                         test_snow3g_auth_cipher_verify_test_case_1),
13329                 TEST_CASE_ST(ut_setup, ut_teardown,
13330                         test_snow3g_auth_cipher_verify_test_case_2),
13331                 TEST_CASE_ST(ut_setup, ut_teardown,
13332                         test_snow3g_auth_cipher_verify_test_case_2_oop),
13333                 TEST_CASE_ST(ut_setup, ut_teardown,
13334                         test_snow3g_auth_cipher_verify_part_digest_enc),
13335                 TEST_CASE_ST(ut_setup, ut_teardown,
13336                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
13337                 TEST_CASE_ST(ut_setup, ut_teardown,
13338                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
13339                 TEST_CASE_ST(ut_setup, ut_teardown,
13340                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
13341                 TEST_CASE_ST(ut_setup, ut_teardown,
13342                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
13343                 TEST_CASE_ST(ut_setup, ut_teardown,
13344                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
13345
13346                 /** SNOW 3G decrypt only (UEA2) */
13347                 TEST_CASE_ST(ut_setup, ut_teardown,
13348                         test_snow3g_decryption_test_case_1),
13349                 TEST_CASE_ST(ut_setup, ut_teardown,
13350                         test_snow3g_decryption_test_case_2),
13351                 TEST_CASE_ST(ut_setup, ut_teardown,
13352                         test_snow3g_decryption_test_case_3),
13353                 TEST_CASE_ST(ut_setup, ut_teardown,
13354                         test_snow3g_decryption_test_case_4),
13355                 TEST_CASE_ST(ut_setup, ut_teardown,
13356                         test_snow3g_decryption_test_case_5),
13357                 TEST_CASE_ST(ut_setup, ut_teardown,
13358                         test_snow3g_decryption_with_digest_test_case_1),
13359                 TEST_CASE_ST(ut_setup, ut_teardown,
13360                         test_snow3g_hash_generate_test_case_1),
13361                 TEST_CASE_ST(ut_setup, ut_teardown,
13362                         test_snow3g_hash_generate_test_case_2),
13363                 TEST_CASE_ST(ut_setup, ut_teardown,
13364                         test_snow3g_hash_generate_test_case_3),
13365                 /* Tests with buffers which length is not byte-aligned */
13366                 TEST_CASE_ST(ut_setup, ut_teardown,
13367                         test_snow3g_hash_generate_test_case_4),
13368                 TEST_CASE_ST(ut_setup, ut_teardown,
13369                         test_snow3g_hash_generate_test_case_5),
13370                 TEST_CASE_ST(ut_setup, ut_teardown,
13371                         test_snow3g_hash_generate_test_case_6),
13372                 TEST_CASE_ST(ut_setup, ut_teardown,
13373                         test_snow3g_hash_verify_test_case_1),
13374                 TEST_CASE_ST(ut_setup, ut_teardown,
13375                         test_snow3g_hash_verify_test_case_2),
13376                 TEST_CASE_ST(ut_setup, ut_teardown,
13377                         test_snow3g_hash_verify_test_case_3),
13378                 /* Tests with buffers which length is not byte-aligned */
13379                 TEST_CASE_ST(ut_setup, ut_teardown,
13380                         test_snow3g_hash_verify_test_case_4),
13381                 TEST_CASE_ST(ut_setup, ut_teardown,
13382                         test_snow3g_hash_verify_test_case_5),
13383                 TEST_CASE_ST(ut_setup, ut_teardown,
13384                         test_snow3g_hash_verify_test_case_6),
13385                 TEST_CASE_ST(ut_setup, ut_teardown,
13386                         test_snow3g_cipher_auth_test_case_1),
13387                 TEST_CASE_ST(ut_setup, ut_teardown,
13388                         test_snow3g_auth_cipher_with_digest_test_case_1),
13389
13390                 /** ZUC encrypt only (EEA3) */
13391                 TEST_CASE_ST(ut_setup, ut_teardown,
13392                         test_zuc_encryption_test_case_1),
13393                 TEST_CASE_ST(ut_setup, ut_teardown,
13394                         test_zuc_encryption_test_case_2),
13395                 TEST_CASE_ST(ut_setup, ut_teardown,
13396                         test_zuc_encryption_test_case_3),
13397                 TEST_CASE_ST(ut_setup, ut_teardown,
13398                         test_zuc_encryption_test_case_4),
13399                 TEST_CASE_ST(ut_setup, ut_teardown,
13400                         test_zuc_encryption_test_case_5),
13401                 TEST_CASE_ST(ut_setup, ut_teardown,
13402                         test_zuc_encryption_test_case_6_sgl),
13403
13404                 /** ZUC authenticate (EIA3) */
13405                 TEST_CASE_ST(ut_setup, ut_teardown,
13406                         test_zuc_hash_generate_test_case_1),
13407                 TEST_CASE_ST(ut_setup, ut_teardown,
13408                         test_zuc_hash_generate_test_case_2),
13409                 TEST_CASE_ST(ut_setup, ut_teardown,
13410                         test_zuc_hash_generate_test_case_3),
13411                 TEST_CASE_ST(ut_setup, ut_teardown,
13412                         test_zuc_hash_generate_test_case_4),
13413                 TEST_CASE_ST(ut_setup, ut_teardown,
13414                         test_zuc_hash_generate_test_case_5),
13415                 TEST_CASE_ST(ut_setup, ut_teardown,
13416                         test_zuc_hash_generate_test_case_6),
13417                 TEST_CASE_ST(ut_setup, ut_teardown,
13418                         test_zuc_hash_generate_test_case_7),
13419                 TEST_CASE_ST(ut_setup, ut_teardown,
13420                         test_zuc_hash_generate_test_case_8),
13421
13422                 /** ZUC alg-chain (EEA3/EIA3) */
13423                 TEST_CASE_ST(ut_setup, ut_teardown,
13424                         test_zuc_cipher_auth_test_case_1),
13425                 TEST_CASE_ST(ut_setup, ut_teardown,
13426                         test_zuc_cipher_auth_test_case_2),
13427
13428                 /** ZUC generate auth, then encrypt (EEA3) */
13429                 TEST_CASE_ST(ut_setup, ut_teardown,
13430                         test_zuc_auth_cipher_test_case_1),
13431                 TEST_CASE_ST(ut_setup, ut_teardown,
13432                         test_zuc_auth_cipher_test_case_1_oop),
13433                 TEST_CASE_ST(ut_setup, ut_teardown,
13434                         test_zuc_auth_cipher_test_case_1_sgl),
13435                 TEST_CASE_ST(ut_setup, ut_teardown,
13436                         test_zuc_auth_cipher_test_case_1_oop_sgl),
13437
13438                 /** ZUC decrypt (EEA3), then verify auth */
13439                 TEST_CASE_ST(ut_setup, ut_teardown,
13440                         test_zuc_auth_cipher_verify_test_case_1),
13441                 TEST_CASE_ST(ut_setup, ut_teardown,
13442                         test_zuc_auth_cipher_verify_test_case_1_oop),
13443                 TEST_CASE_ST(ut_setup, ut_teardown,
13444                         test_zuc_auth_cipher_verify_test_case_1_sgl),
13445                 TEST_CASE_ST(ut_setup, ut_teardown,
13446                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
13447
13448                 /** HMAC_MD5 Authentication */
13449                 TEST_CASE_ST(ut_setup, ut_teardown,
13450                         test_MD5_HMAC_generate_case_1),
13451                 TEST_CASE_ST(ut_setup, ut_teardown,
13452                         test_MD5_HMAC_verify_case_1),
13453                 TEST_CASE_ST(ut_setup, ut_teardown,
13454                         test_MD5_HMAC_generate_case_2),
13455                 TEST_CASE_ST(ut_setup, ut_teardown,
13456                         test_MD5_HMAC_verify_case_2),
13457
13458                 /** KASUMI hash only (UIA1) */
13459                 TEST_CASE_ST(ut_setup, ut_teardown,
13460                         test_kasumi_hash_generate_test_case_1),
13461                 TEST_CASE_ST(ut_setup, ut_teardown,
13462                         test_kasumi_hash_generate_test_case_2),
13463                 TEST_CASE_ST(ut_setup, ut_teardown,
13464                         test_kasumi_hash_generate_test_case_3),
13465                 TEST_CASE_ST(ut_setup, ut_teardown,
13466                         test_kasumi_hash_generate_test_case_4),
13467                 TEST_CASE_ST(ut_setup, ut_teardown,
13468                         test_kasumi_hash_generate_test_case_5),
13469                 TEST_CASE_ST(ut_setup, ut_teardown,
13470                         test_kasumi_hash_generate_test_case_6),
13471
13472                 TEST_CASE_ST(ut_setup, ut_teardown,
13473                         test_kasumi_hash_verify_test_case_1),
13474                 TEST_CASE_ST(ut_setup, ut_teardown,
13475                         test_kasumi_hash_verify_test_case_2),
13476                 TEST_CASE_ST(ut_setup, ut_teardown,
13477                         test_kasumi_hash_verify_test_case_3),
13478                 TEST_CASE_ST(ut_setup, ut_teardown,
13479                         test_kasumi_hash_verify_test_case_4),
13480                 TEST_CASE_ST(ut_setup, ut_teardown,
13481                         test_kasumi_hash_verify_test_case_5),
13482
13483                 /** KASUMI encrypt only (UEA1) */
13484                 TEST_CASE_ST(ut_setup, ut_teardown,
13485                         test_kasumi_encryption_test_case_1),
13486                 TEST_CASE_ST(ut_setup, ut_teardown,
13487                         test_kasumi_encryption_test_case_1_sgl),
13488                 TEST_CASE_ST(ut_setup, ut_teardown,
13489                         test_kasumi_encryption_test_case_1_oop),
13490                 TEST_CASE_ST(ut_setup, ut_teardown,
13491                         test_kasumi_encryption_test_case_1_oop_sgl),
13492                 TEST_CASE_ST(ut_setup, ut_teardown,
13493                         test_kasumi_encryption_test_case_2),
13494                 TEST_CASE_ST(ut_setup, ut_teardown,
13495                         test_kasumi_encryption_test_case_3),
13496                 TEST_CASE_ST(ut_setup, ut_teardown,
13497                         test_kasumi_encryption_test_case_4),
13498                 TEST_CASE_ST(ut_setup, ut_teardown,
13499                         test_kasumi_encryption_test_case_5),
13500
13501                 /** KASUMI decrypt only (UEA1) */
13502                 TEST_CASE_ST(ut_setup, ut_teardown,
13503                         test_kasumi_decryption_test_case_1),
13504                 TEST_CASE_ST(ut_setup, ut_teardown,
13505                         test_kasumi_decryption_test_case_2),
13506                 TEST_CASE_ST(ut_setup, ut_teardown,
13507                         test_kasumi_decryption_test_case_3),
13508                 TEST_CASE_ST(ut_setup, ut_teardown,
13509                         test_kasumi_decryption_test_case_4),
13510                 TEST_CASE_ST(ut_setup, ut_teardown,
13511                         test_kasumi_decryption_test_case_5),
13512                 TEST_CASE_ST(ut_setup, ut_teardown,
13513                         test_kasumi_decryption_test_case_1_oop),
13514
13515                 TEST_CASE_ST(ut_setup, ut_teardown,
13516                         test_kasumi_cipher_auth_test_case_1),
13517
13518                 /** KASUMI generate auth, then encrypt (F8) */
13519                 TEST_CASE_ST(ut_setup, ut_teardown,
13520                         test_kasumi_auth_cipher_test_case_1),
13521                 TEST_CASE_ST(ut_setup, ut_teardown,
13522                         test_kasumi_auth_cipher_test_case_2),
13523                 TEST_CASE_ST(ut_setup, ut_teardown,
13524                         test_kasumi_auth_cipher_test_case_2_oop),
13525                 TEST_CASE_ST(ut_setup, ut_teardown,
13526                         test_kasumi_auth_cipher_test_case_2_sgl),
13527                 TEST_CASE_ST(ut_setup, ut_teardown,
13528                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
13529
13530                 /** KASUMI decrypt (F8), then verify auth */
13531                 TEST_CASE_ST(ut_setup, ut_teardown,
13532                         test_kasumi_auth_cipher_verify_test_case_1),
13533                 TEST_CASE_ST(ut_setup, ut_teardown,
13534                         test_kasumi_auth_cipher_verify_test_case_2),
13535                 TEST_CASE_ST(ut_setup, ut_teardown,
13536                         test_kasumi_auth_cipher_verify_test_case_2_oop),
13537                 TEST_CASE_ST(ut_setup, ut_teardown,
13538                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
13539                 TEST_CASE_ST(ut_setup, ut_teardown,
13540                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
13541
13542                 /** ESN Testcase */
13543                 TEST_CASE_ST(ut_setup, ut_teardown,
13544                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
13545                 TEST_CASE_ST(ut_setup, ut_teardown,
13546                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
13547
13548                 /** Negative tests */
13549                 TEST_CASE_ST(ut_setup, ut_teardown,
13550                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13551                 TEST_CASE_ST(ut_setup, ut_teardown,
13552                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13553                 TEST_CASE_ST(ut_setup, ut_teardown,
13554                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
13555                 TEST_CASE_ST(ut_setup, ut_teardown,
13556                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
13557                 TEST_CASE_ST(ut_setup, ut_teardown,
13558                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
13559                 TEST_CASE_ST(ut_setup, ut_teardown,
13560                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
13561                 TEST_CASE_ST(ut_setup, ut_teardown,
13562                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
13563                 TEST_CASE_ST(ut_setup, ut_teardown,
13564                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
13565                 TEST_CASE_ST(ut_setup, ut_teardown,
13566                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
13567                 TEST_CASE_ST(ut_setup, ut_teardown,
13568                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
13569                 TEST_CASE_ST(ut_setup, ut_teardown,
13570                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
13571                 TEST_CASE_ST(ut_setup, ut_teardown,
13572                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
13573                 TEST_CASE_ST(ut_setup, ut_teardown,
13574                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
13575                 TEST_CASE_ST(ut_setup, ut_teardown,
13576                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
13577                 TEST_CASE_ST(ut_setup, ut_teardown,
13578                         authentication_verify_AES128_GMAC_fail_data_corrupt),
13579                 TEST_CASE_ST(ut_setup, ut_teardown,
13580                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
13581                 TEST_CASE_ST(ut_setup, ut_teardown,
13582                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13583                 TEST_CASE_ST(ut_setup, ut_teardown,
13584                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13585
13586                 /** Mixed CIPHER + HASH algorithms */
13587                 /** AUTH AES CMAC + CIPHER AES CTR */
13588                 TEST_CASE_ST(ut_setup, ut_teardown,
13589                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
13590                 TEST_CASE_ST(ut_setup, ut_teardown,
13591                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13592                 TEST_CASE_ST(ut_setup, ut_teardown,
13593                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13594                 TEST_CASE_ST(ut_setup, ut_teardown,
13595                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13596                 TEST_CASE_ST(ut_setup, ut_teardown,
13597                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
13598                 TEST_CASE_ST(ut_setup, ut_teardown,
13599                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
13600                 TEST_CASE_ST(ut_setup, ut_teardown,
13601                        test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
13602                 TEST_CASE_ST(ut_setup, ut_teardown,
13603                    test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
13604
13605                 /** AUTH ZUC + CIPHER SNOW3G */
13606                 TEST_CASE_ST(ut_setup, ut_teardown,
13607                         test_auth_zuc_cipher_snow_test_case_1),
13608                 TEST_CASE_ST(ut_setup, ut_teardown,
13609                         test_verify_auth_zuc_cipher_snow_test_case_1),
13610                 /** AUTH AES CMAC + CIPHER SNOW3G */
13611                 TEST_CASE_ST(ut_setup, ut_teardown,
13612                         test_auth_aes_cmac_cipher_snow_test_case_1),
13613                 TEST_CASE_ST(ut_setup, ut_teardown,
13614                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
13615                 /** AUTH ZUC + CIPHER AES CTR */
13616                 TEST_CASE_ST(ut_setup, ut_teardown,
13617                         test_auth_zuc_cipher_aes_ctr_test_case_1),
13618                 TEST_CASE_ST(ut_setup, ut_teardown,
13619                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
13620                 /** AUTH SNOW3G + CIPHER AES CTR */
13621                 TEST_CASE_ST(ut_setup, ut_teardown,
13622                         test_auth_snow_cipher_aes_ctr_test_case_1),
13623                 TEST_CASE_ST(ut_setup, ut_teardown,
13624                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
13625                 /** AUTH SNOW3G + CIPHER ZUC */
13626                 TEST_CASE_ST(ut_setup, ut_teardown,
13627                         test_auth_snow_cipher_zuc_test_case_1),
13628                 TEST_CASE_ST(ut_setup, ut_teardown,
13629                         test_verify_auth_snow_cipher_zuc_test_case_1),
13630                 /** AUTH AES CMAC + CIPHER ZUC */
13631                 TEST_CASE_ST(ut_setup, ut_teardown,
13632                         test_auth_aes_cmac_cipher_zuc_test_case_1),
13633                 TEST_CASE_ST(ut_setup, ut_teardown,
13634                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
13635
13636                 /** AUTH NULL + CIPHER SNOW3G */
13637                 TEST_CASE_ST(ut_setup, ut_teardown,
13638                         test_auth_null_cipher_snow_test_case_1),
13639                 TEST_CASE_ST(ut_setup, ut_teardown,
13640                         test_verify_auth_null_cipher_snow_test_case_1),
13641                 /** AUTH NULL + CIPHER ZUC */
13642                 TEST_CASE_ST(ut_setup, ut_teardown,
13643                         test_auth_null_cipher_zuc_test_case_1),
13644                 TEST_CASE_ST(ut_setup, ut_teardown,
13645                         test_verify_auth_null_cipher_zuc_test_case_1),
13646                 /** AUTH SNOW3G + CIPHER NULL */
13647                 TEST_CASE_ST(ut_setup, ut_teardown,
13648                         test_auth_snow_cipher_null_test_case_1),
13649                 TEST_CASE_ST(ut_setup, ut_teardown,
13650                         test_verify_auth_snow_cipher_null_test_case_1),
13651                 /** AUTH ZUC + CIPHER NULL */
13652                 TEST_CASE_ST(ut_setup, ut_teardown,
13653                         test_auth_zuc_cipher_null_test_case_1),
13654                 TEST_CASE_ST(ut_setup, ut_teardown,
13655                         test_verify_auth_zuc_cipher_null_test_case_1),
13656                 /** AUTH NULL + CIPHER AES CTR */
13657                 TEST_CASE_ST(ut_setup, ut_teardown,
13658                         test_auth_null_cipher_aes_ctr_test_case_1),
13659                 TEST_CASE_ST(ut_setup, ut_teardown,
13660                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
13661                 /** AUTH AES CMAC + CIPHER NULL */
13662                 TEST_CASE_ST(ut_setup, ut_teardown,
13663                         test_auth_aes_cmac_cipher_null_test_case_1),
13664                 TEST_CASE_ST(ut_setup, ut_teardown,
13665                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
13666
13667 #ifdef RTE_LIB_SECURITY
13668                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13669                         test_PDCP_PROTO_all),
13670                 TEST_CASE_ST(ut_setup_security, ut_teardown,
13671                         test_DOCSIS_PROTO_all),
13672 #endif
13673                 TEST_CASES_END() /**< NULL terminate unit test array */
13674         }
13675 };
13676
13677 static struct unit_test_suite cryptodev_virtio_testsuite = {
13678         .suite_name = "Crypto VIRTIO Unit Test Suite",
13679         .setup = testsuite_setup,
13680         .teardown = testsuite_teardown,
13681         .unit_test_cases = {
13682                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13683
13684                 TEST_CASES_END() /**< NULL terminate unit test array */
13685         }
13686 };
13687
13688 static struct unit_test_suite cryptodev_caam_jr_testsuite  = {
13689         .suite_name = "Crypto CAAM JR Unit Test Suite",
13690         .setup = testsuite_setup,
13691         .teardown = testsuite_teardown,
13692         .unit_test_cases = {
13693                 TEST_CASE_ST(ut_setup, ut_teardown,
13694                              test_device_configure_invalid_dev_id),
13695                 TEST_CASE_ST(ut_setup, ut_teardown,
13696                              test_multi_session),
13697
13698                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13699                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13700                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13701                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13702                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13703
13704                 TEST_CASES_END() /**< NULL terminate unit test array */
13705         }
13706 };
13707
13708 static struct unit_test_suite cryptodev_mrvl_testsuite  = {
13709         .suite_name = "Crypto Device Marvell Component Test Suite",
13710         .setup = testsuite_setup,
13711         .teardown = testsuite_teardown,
13712         .unit_test_cases = {
13713                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13714                 TEST_CASE_ST(ut_setup, ut_teardown,
13715                                 test_multi_session_random_usage),
13716                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13717                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13718                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13719                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13720                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13721
13722                 /** Negative tests */
13723                 TEST_CASE_ST(ut_setup, ut_teardown,
13724                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13725                 TEST_CASE_ST(ut_setup, ut_teardown,
13726                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13727                 TEST_CASE_ST(ut_setup, ut_teardown,
13728                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13729                 TEST_CASE_ST(ut_setup, ut_teardown,
13730                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13731
13732                 TEST_CASES_END() /**< NULL terminate unit test array */
13733         }
13734 };
13735
13736 static struct unit_test_suite cryptodev_ccp_testsuite  = {
13737         .suite_name = "Crypto Device CCP Unit Test Suite",
13738         .setup = testsuite_setup,
13739         .teardown = testsuite_teardown,
13740         .unit_test_cases = {
13741                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
13742                 TEST_CASE_ST(ut_setup, ut_teardown,
13743                                 test_multi_session_random_usage),
13744                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
13745                 TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
13746                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
13747                 TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
13748                 TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
13749
13750                 /** Negative tests */
13751                 TEST_CASE_ST(ut_setup, ut_teardown,
13752                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
13753                 TEST_CASE_ST(ut_setup, ut_teardown,
13754                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
13755                 TEST_CASE_ST(ut_setup, ut_teardown,
13756                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
13757                 TEST_CASE_ST(ut_setup, ut_teardown,
13758                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
13759
13760                 TEST_CASES_END() /**< NULL terminate unit test array */
13761         }
13762 };
13763
13764 static int
13765 test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
13766 {
13767         gbl_driver_id = rte_cryptodev_driver_id_get(
13768                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
13769
13770         if (gbl_driver_id == -1) {
13771                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
13772                 return TEST_SKIPPED;
13773         }
13774
13775         return unit_test_suite_runner(&cryptodev_testsuite);
13776 }
13777
13778 static int
13779 test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
13780 {
13781         gbl_driver_id = rte_cryptodev_driver_id_get(
13782                         RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
13783
13784         if (gbl_driver_id == -1) {
13785                 RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded.\n");
13786                 return TEST_FAILED;
13787         }
13788
13789         return unit_test_suite_runner(&cryptodev_virtio_testsuite);
13790 }
13791
13792 static int
13793 test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
13794 {
13795         gbl_driver_id = rte_cryptodev_driver_id_get(
13796                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13797
13798         if (gbl_driver_id == -1) {
13799                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13800                 return TEST_SKIPPED;
13801         }
13802
13803         return unit_test_suite_runner(&cryptodev_testsuite);
13804 }
13805
13806 static int
13807 test_cryptodev_cpu_aesni_mb(void)
13808 {
13809         int32_t rc;
13810         enum rte_security_session_action_type at;
13811
13812         gbl_driver_id = rte_cryptodev_driver_id_get(
13813                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
13814
13815         if (gbl_driver_id == -1) {
13816                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13817                 return TEST_SKIPPED;
13818         }
13819
13820         at = gbl_action_type;
13821         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13822         rc = unit_test_suite_runner(&cryptodev_testsuite);
13823         gbl_action_type = at;
13824         return rc;
13825 }
13826
13827 static int
13828 test_cryptodev_openssl(void)
13829 {
13830         gbl_driver_id = rte_cryptodev_driver_id_get(
13831                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
13832
13833         if (gbl_driver_id == -1) {
13834                 RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
13835                 return TEST_SKIPPED;
13836         }
13837
13838         return unit_test_suite_runner(&cryptodev_testsuite);
13839 }
13840
13841 static int
13842 test_cryptodev_aesni_gcm(void)
13843 {
13844         gbl_driver_id = rte_cryptodev_driver_id_get(
13845                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13846
13847         if (gbl_driver_id == -1) {
13848                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13849                 return TEST_SKIPPED;
13850         }
13851
13852         return unit_test_suite_runner(&cryptodev_testsuite);
13853 }
13854
13855 static int
13856 test_cryptodev_cpu_aesni_gcm(void)
13857 {
13858         int32_t rc;
13859         enum rte_security_session_action_type at;
13860
13861         gbl_driver_id = rte_cryptodev_driver_id_get(
13862                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
13863
13864         if (gbl_driver_id == -1) {
13865                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
13866                 return TEST_SKIPPED;
13867         }
13868
13869         at = gbl_action_type;
13870         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
13871         rc = unit_test_suite_runner(&cryptodev_testsuite);
13872         gbl_action_type = at;
13873         return rc;
13874 }
13875
13876 static int
13877 test_cryptodev_null(void)
13878 {
13879         gbl_driver_id = rte_cryptodev_driver_id_get(
13880                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
13881
13882         if (gbl_driver_id == -1) {
13883                 RTE_LOG(ERR, USER1, "NULL PMD must be loaded.\n");
13884                 return TEST_SKIPPED;
13885         }
13886
13887         return unit_test_suite_runner(&cryptodev_testsuite);
13888 }
13889
13890 static int
13891 test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
13892 {
13893         gbl_driver_id = rte_cryptodev_driver_id_get(
13894                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
13895
13896         if (gbl_driver_id == -1) {
13897                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded.\n");
13898                 return TEST_SKIPPED;
13899         }
13900
13901         return unit_test_suite_runner(&cryptodev_testsuite);
13902 }
13903
13904 static int
13905 test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
13906 {
13907         gbl_driver_id = rte_cryptodev_driver_id_get(
13908                         RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
13909
13910         if (gbl_driver_id == -1) {
13911                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13912                 return TEST_SKIPPED;
13913         }
13914
13915         return unit_test_suite_runner(&cryptodev_testsuite);
13916 }
13917
13918 static int
13919 test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
13920 {
13921         gbl_driver_id = rte_cryptodev_driver_id_get(
13922                         RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
13923
13924         if (gbl_driver_id == -1) {
13925                 RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
13926                 return TEST_SKIPPED;
13927         }
13928
13929         return unit_test_suite_runner(&cryptodev_testsuite);
13930 }
13931
13932 static int
13933 test_cryptodev_armv8(void)
13934 {
13935         gbl_driver_id = rte_cryptodev_driver_id_get(
13936                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
13937
13938         if (gbl_driver_id == -1) {
13939                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded.\n");
13940                 return TEST_SKIPPED;
13941         }
13942
13943         return unit_test_suite_runner(&cryptodev_testsuite);
13944 }
13945
13946 static int
13947 test_cryptodev_mrvl(void)
13948 {
13949         gbl_driver_id = rte_cryptodev_driver_id_get(
13950                         RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
13951
13952         if (gbl_driver_id == -1) {
13953                 RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded.\n");
13954                 return TEST_SKIPPED;
13955         }
13956
13957         return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
13958 }
13959
13960 #ifdef RTE_CRYPTO_SCHEDULER
13961
13962 static int
13963 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
13964 {
13965         gbl_driver_id = rte_cryptodev_driver_id_get(
13966                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
13967
13968         if (gbl_driver_id == -1) {
13969                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
13970                 return TEST_SKIPPED;
13971         }
13972
13973         if (rte_cryptodev_driver_id_get(
13974                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
13975                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
13976                 return TEST_SKIPPED;
13977 }
13978         return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
13979 }
13980
13981 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
13982
13983 #endif
13984
13985 static int
13986 test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
13987 {
13988         gbl_driver_id = rte_cryptodev_driver_id_get(
13989                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
13990
13991         if (gbl_driver_id == -1) {
13992                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded.\n");
13993                 return TEST_SKIPPED;
13994         }
13995
13996         return unit_test_suite_runner(&cryptodev_testsuite);
13997 }
13998
13999 static int
14000 test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
14001 {
14002         gbl_driver_id = rte_cryptodev_driver_id_get(
14003                         RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
14004
14005         if (gbl_driver_id == -1) {
14006                 RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded.\n");
14007                 return TEST_SKIPPED;
14008         }
14009
14010         return unit_test_suite_runner(&cryptodev_testsuite);
14011 }
14012
14013 static int
14014 test_cryptodev_ccp(void)
14015 {
14016         gbl_driver_id = rte_cryptodev_driver_id_get(
14017                         RTE_STR(CRYPTODEV_NAME_CCP_PMD));
14018
14019         if (gbl_driver_id == -1) {
14020                 RTE_LOG(ERR, USER1, "CCP PMD must be loaded.\n");
14021                 return TEST_FAILED;
14022         }
14023
14024         return unit_test_suite_runner(&cryptodev_ccp_testsuite);
14025 }
14026
14027 static int
14028 test_cryptodev_octeontx(void)
14029 {
14030         gbl_driver_id = rte_cryptodev_driver_id_get(
14031                         RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
14032         if (gbl_driver_id == -1) {
14033                 RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
14034                 return TEST_FAILED;
14035         }
14036         return unit_test_suite_runner(&cryptodev_testsuite);
14037 }
14038
14039 static int
14040 test_cryptodev_octeontx2(void)
14041 {
14042         gbl_driver_id = rte_cryptodev_driver_id_get(
14043                         RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
14044         if (gbl_driver_id == -1) {
14045                 RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded.\n");
14046                 return TEST_FAILED;
14047         }
14048         return unit_test_suite_runner(&cryptodev_testsuite);
14049 }
14050
14051 static int
14052 test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
14053 {
14054         gbl_driver_id = rte_cryptodev_driver_id_get(
14055                         RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
14056
14057         if (gbl_driver_id == -1) {
14058                 RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded.\n");
14059                 return TEST_FAILED;
14060         }
14061
14062         return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
14063 }
14064
14065 static int
14066 test_cryptodev_nitrox(void)
14067 {
14068         gbl_driver_id = rte_cryptodev_driver_id_get(
14069                         RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
14070
14071         if (gbl_driver_id == -1) {
14072                 RTE_LOG(ERR, USER1, "NITROX PMD must be loaded.\n");
14073                 return TEST_FAILED;
14074         }
14075
14076         return unit_test_suite_runner(&cryptodev_testsuite);
14077 }
14078
14079 static int
14080 test_cryptodev_bcmfs(void)
14081 {
14082         gbl_driver_id = rte_cryptodev_driver_id_get(
14083                         RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
14084
14085         if (gbl_driver_id == -1) {
14086                 RTE_LOG(ERR, USER1, "BCMFS PMD must be loaded.\n");
14087                 return TEST_FAILED;
14088         }
14089
14090         return unit_test_suite_runner(&cryptodev_testsuite);
14091 }
14092
14093 static int
14094 test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
14095 {
14096         int ret;
14097
14098         gbl_driver_id = rte_cryptodev_driver_id_get(
14099                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
14100
14101         if (gbl_driver_id == -1) {
14102                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
14103                 return TEST_SKIPPED;
14104         }
14105
14106         global_api_test_type = CRYPTODEV_RAW_API_TEST;
14107         ret = unit_test_suite_runner(&cryptodev_testsuite);
14108         global_api_test_type = CRYPTODEV_API_TEST;
14109
14110         return ret;
14111 }
14112
14113 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
14114                 test_cryptodev_qat_raw_api);
14115 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
14116 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
14117 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
14118         test_cryptodev_cpu_aesni_mb);
14119 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
14120 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
14121 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
14122         test_cryptodev_cpu_aesni_gcm);
14123 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
14124 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
14125 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
14126 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
14127 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
14128 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
14129 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
14130 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
14131 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
14132 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
14133 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
14134 REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2);
14135 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
14136 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
14137 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);