app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #include <time.h>
   7
   8 #include <rte_common.h>
   9 #include <rte_hexdump.h>
  10 #include <rte_mbuf.h>
  11 #include <rte_malloc.h>
  12 #include <rte_memcpy.h>
  13 #include <rte_pause.h>
  14 #include <rte_bus_vdev.h>
  15 #include <rte_ether.h>
  16
  17 #include <rte_crypto.h>
  18 #include <rte_cryptodev.h>
  19 #include <rte_ip.h>
  20 #include <rte_string_fns.h>
  21 #include <rte_tcp.h>
  22 #include <rte_udp.h>
  23
  24 #ifdef RTE_CRYPTO_SCHEDULER
  25 #include <rte_cryptodev_scheduler.h>
  26 #include <rte_cryptodev_scheduler_operations.h>
  27 #endif
  28
  29 #include <rte_lcore.h>
  30
  31 #include "test.h"
  32 #include "test_cryptodev.h"
  33
  34 #include "test_cryptodev_blockcipher.h"
  35 #include "test_cryptodev_aes_test_vectors.h"
  36 #include "test_cryptodev_des_test_vectors.h"
  37 #include "test_cryptodev_hash_test_vectors.h"
  38 #include "test_cryptodev_kasumi_test_vectors.h"
  39 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  40 #include "test_cryptodev_snow3g_test_vectors.h"
  41 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  42 #include "test_cryptodev_zuc_test_vectors.h"
  43 #include "test_cryptodev_aead_test_vectors.h"
  44 #include "test_cryptodev_hmac_test_vectors.h"
  45 #include "test_cryptodev_mixed_test_vectors.h"
  46 #ifdef RTE_LIB_SECURITY
  47 #include "test_cryptodev_security_ipsec.h"
  48 #include "test_cryptodev_security_ipsec_test_vectors.h"
  49 #include "test_cryptodev_security_pdcp_test_vectors.h"
  50 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_func.h"
  52 #include "test_cryptodev_security_docsis_test_vectors.h"
  53
  54 #define SDAP_DISABLED   0
  55 #define SDAP_ENABLED    1
  56 #endif
  57
  58 #define VDEV_ARGS_SIZE 100
  59 #define MAX_NB_SESSIONS 4
  60
  61 #define MAX_DRV_SERVICE_CTX_SIZE 256
  62
  63 #define MAX_RAW_DEQUEUE_COUNT   65535
  64
  65 #define IN_PLACE 0
  66 #define OUT_OF_PLACE 1
  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_unittest_params {
  76         struct rte_crypto_sym_xform cipher_xform;
  77         struct rte_crypto_sym_xform auth_xform;
  78         struct rte_crypto_sym_xform aead_xform;
  79 #ifdef RTE_LIB_SECURITY
  80         struct rte_security_docsis_xform docsis_xform;
  81 #endif
  82
  83         union {
  84                 struct rte_cryptodev_sym_session *sess;
  85 #ifdef RTE_LIB_SECURITY
  86                 struct rte_security_session *sec_session;
  87 #endif
  88         };
  89 #ifdef RTE_LIB_SECURITY
  90         enum rte_security_session_action_type type;
  91 #endif
  92         struct rte_crypto_op *op;
  93
  94         struct rte_mbuf *obuf, *ibuf;
  95
  96         uint8_t *digest;
  97 };
  98
  99 #define ALIGN_POW2_ROUNDUP(num, align) \
 100         (((num) + (align) - 1) & ~((align) - 1))
 101
 102 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 103         for (j = 0; j < num_child_ts; index++, j++)                     \
 104                 parent_ts.unit_test_suites[index] = child_ts[j]
 105
 106 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 107         for (j = 0; j < num_blk_types; index++, j++)                            \
 108                 parent_ts.unit_test_suites[index] =                             \
 109                                 build_blockcipher_test_suite(blk_types[j])
 110
 111 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 112         for (j = index; j < index + num_blk_types; j++)                         \
 113                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 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 int
 132 security_proto_supported(enum rte_security_session_action_type action,
 133         enum rte_security_session_protocol proto);
 134
 135 static int
 136 dev_configure_and_start(uint64_t ff_disable);
 137
 138 static struct rte_mbuf *
 139 setup_test_string(struct rte_mempool *mpool,
 140                 const char *string, size_t len, uint8_t blocksize)
 141 {
 142         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 143         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 144
 145         if (m) {
 146                 char *dst;
 147
 148                 memset(m->buf_addr, 0, m->buf_len);
 149                 dst = rte_pktmbuf_append(m, t_len);
 150                 if (!dst) {
 151                         rte_pktmbuf_free(m);
 152                         return NULL;
 153                 }
 154                 if (string != NULL)
 155                         rte_memcpy(dst, string, t_len);
 156                 else
 157                         memset(dst, 0, t_len);
 158         }
 159
 160         return m;
 161 }
 162
 163 /* Get number of bytes in X bits (rounding up) */
 164 static uint32_t
 165 ceil_byte_length(uint32_t num_bits)
 166 {
 167         if (num_bits % 8)
 168                 return ((num_bits >> 3) + 1);
 169         else
 170                 return (num_bits >> 3);
 171 }
 172
 173 static void
 174 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 175                 uint8_t is_op_success)
 176 {
 177         struct rte_crypto_op *op = user_data;
 178         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 179                         RTE_CRYPTO_OP_STATUS_ERROR;
 180 }
 181
 182 static struct crypto_testsuite_params testsuite_params = { NULL };
 183 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 184 static struct crypto_unittest_params unittest_params;
 185
 186 void
 187 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 188                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 189                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 190 {
 191         struct rte_crypto_sym_op *sop = op->sym;
 192         struct rte_crypto_op *ret_op = NULL;
 193         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 194         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 195         union rte_crypto_sym_ofs ofs;
 196         struct rte_crypto_sym_vec vec;
 197         struct rte_crypto_sgl sgl, dest_sgl;
 198         uint32_t max_len;
 199         union rte_cryptodev_session_ctx sess;
 200         uint64_t auth_end_iova;
 201         uint32_t count = 0;
 202         struct rte_crypto_raw_dp_ctx *ctx;
 203         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 204                         auth_len = 0;
 205         int32_t n;
 206         uint32_t n_success;
 207         int ctx_service_size;
 208         int32_t status = 0;
 209         int enqueue_status, dequeue_status;
 210         struct crypto_unittest_params *ut_params = &unittest_params;
 211         int is_sgl = sop->m_src->nb_segs > 1;
 212
 213         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 214         if (ctx_service_size < 0) {
 215                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 216                 return;
 217         }
 218
 219         ctx = malloc(ctx_service_size);
 220         if (!ctx) {
 221                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 222                 return;
 223         }
 224
 225         /* Both are enums, setting crypto_sess will suit any session type */
 226         sess.crypto_sess = op->sym->session;
 227
 228         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 229                         op->sess_type, sess, 0) < 0) {
 230                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 231                 goto exit;
 232         }
 233
 234         cipher_iv.iova = 0;
 235         cipher_iv.va = NULL;
 236         aad_auth_iv.iova = 0;
 237         aad_auth_iv.va = NULL;
 238         digest.iova = 0;
 239         digest.va = NULL;
 240         sgl.vec = data_vec;
 241         vec.num = 1;
 242         vec.src_sgl = &sgl;
 243         vec.iv = &cipher_iv;
 244         vec.digest = &digest;
 245         vec.aad = &aad_auth_iv;
 246         vec.status = &status;
 247
 248         ofs.raw = 0;
 249
 250         if (is_cipher && is_auth) {
 251                 cipher_offset = sop->cipher.data.offset;
 252                 cipher_len = sop->cipher.data.length;
 253                 auth_offset = sop->auth.data.offset;
 254                 auth_len = sop->auth.data.length;
 255                 max_len = RTE_MAX(cipher_offset + cipher_len,
 256                                 auth_offset + auth_len);
 257                 if (len_in_bits) {
 258                         max_len = max_len >> 3;
 259                         cipher_offset = cipher_offset >> 3;
 260                         auth_offset = auth_offset >> 3;
 261                         cipher_len = cipher_len >> 3;
 262                         auth_len = auth_len >> 3;
 263                 }
 264                 ofs.ofs.cipher.head = cipher_offset;
 265                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 266                 ofs.ofs.auth.head = auth_offset;
 267                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 268                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 269                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 270                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 271                                 op, void *, IV_OFFSET + cipher_iv_len);
 272                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 273                                 cipher_iv_len);
 274                 digest.va = (void *)sop->auth.digest.data;
 275                 digest.iova = sop->auth.digest.phys_addr;
 276
 277                 if (is_sgl) {
 278                         uint32_t remaining_off = auth_offset + auth_len;
 279                         struct rte_mbuf *sgl_buf = sop->m_src;
 280
 281                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 282                                         && sgl_buf->next != NULL) {
 283                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 284                                 sgl_buf = sgl_buf->next;
 285                         }
 286
 287                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 288                                 sgl_buf, remaining_off);
 289                 } else {
 290                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 291                                                          auth_offset + auth_len;
 292                 }
 293                 /* Then check if digest-encrypted conditions are met */
 294                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 295                                 (digest.iova == auth_end_iova) && is_sgl)
 296                         max_len = RTE_MAX(max_len, auth_offset + auth_len +
 297                                 ut_params->auth_xform.auth.digest_length);
 298
 299         } else if (is_cipher) {
 300                 cipher_offset = sop->cipher.data.offset;
 301                 cipher_len = sop->cipher.data.length;
 302                 max_len = cipher_len + cipher_offset;
 303                 if (len_in_bits) {
 304                         max_len = max_len >> 3;
 305                         cipher_offset = cipher_offset >> 3;
 306                         cipher_len = cipher_len >> 3;
 307                 }
 308                 ofs.ofs.cipher.head = cipher_offset;
 309                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 310                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 311                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 312
 313         } else if (is_auth) {
 314                 auth_offset = sop->auth.data.offset;
 315                 auth_len = sop->auth.data.length;
 316                 max_len = auth_len + auth_offset;
 317                 if (len_in_bits) {
 318                         max_len = max_len >> 3;
 319                         auth_offset = auth_offset >> 3;
 320                         auth_len = auth_len >> 3;
 321                 }
 322                 ofs.ofs.auth.head = auth_offset;
 323                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 324                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 325                                 op, void *, IV_OFFSET + cipher_iv_len);
 326                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 327                                 cipher_iv_len);
 328                 digest.va = (void *)sop->auth.digest.data;
 329                 digest.iova = sop->auth.digest.phys_addr;
 330
 331         } else { /* aead */
 332                 cipher_offset = sop->aead.data.offset;
 333                 cipher_len = sop->aead.data.length;
 334                 max_len = cipher_len + cipher_offset;
 335                 if (len_in_bits) {
 336                         max_len = max_len >> 3;
 337                         cipher_offset = cipher_offset >> 3;
 338                         cipher_len = cipher_len >> 3;
 339                 }
 340                 ofs.ofs.cipher.head = cipher_offset;
 341                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 342                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 343                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 344                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 345                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 346                 digest.va = (void *)sop->aead.digest.data;
 347                 digest.iova = sop->aead.digest.phys_addr;
 348         }
 349
 350         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 351                         data_vec, RTE_DIM(data_vec));
 352         if (n < 0 || n > sop->m_src->nb_segs) {
 353                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 354                 goto exit;
 355         }
 356
 357         sgl.num = n;
 358         /* Out of place */
 359         if (sop->m_dst != NULL) {
 360                 dest_sgl.vec = dest_data_vec;
 361                 vec.dest_sgl = &dest_sgl;
 362                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 363                                 dest_data_vec, RTE_DIM(dest_data_vec));
 364                 if (n < 0 || n > sop->m_dst->nb_segs) {
 365                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 366                         goto exit;
 367                 }
 368                 dest_sgl.num = n;
 369         } else
 370                 vec.dest_sgl = NULL;
 371
 372         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 373                         &enqueue_status) < 1) {
 374                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                 goto exit;
 376         }
 377
 378         if (enqueue_status == 0) {
 379                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 380                 if (status < 0) {
 381                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 382                         goto exit;
 383                 }
 384         } else if (enqueue_status < 0) {
 385                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 386                 goto exit;
 387         }
 388
 389         n = n_success = 0;
 390         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 391                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 392                         NULL, 1, post_process_raw_dp_op,
 393                                 (void **)&ret_op, 0, &n_success,
 394                                 &dequeue_status);
 395                 if (dequeue_status < 0) {
 396                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 397                         goto exit;
 398                 }
 399                 if (n == 0)
 400                         rte_pause();
 401         }
 402
 403         if (n == 1 && dequeue_status == 0) {
 404                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408         }
 409
 410         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 411                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 412                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 413                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 414
 415 exit:
 416         free(ctx);
 417 }
 418
 419 static void
 420 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 421 {
 422         int32_t n, st;
 423         struct rte_crypto_sym_op *sop;
 424         union rte_crypto_sym_ofs ofs;
 425         struct rte_crypto_sgl sgl;
 426         struct rte_crypto_sym_vec symvec;
 427         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 428         struct rte_crypto_vec vec[UINT8_MAX];
 429
 430         sop = op->sym;
 431
 432         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 433                 sop->aead.data.length, vec, RTE_DIM(vec));
 434
 435         if (n < 0 || n != sop->m_src->nb_segs) {
 436                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 437                 return;
 438         }
 439
 440         sgl.vec = vec;
 441         sgl.num = n;
 442         symvec.src_sgl = &sgl;
 443         symvec.iv = &iv_ptr;
 444         symvec.digest = &digest_ptr;
 445         symvec.aad = &aad_ptr;
 446         symvec.status = &st;
 447         symvec.num = 1;
 448
 449         /* for CPU crypto the IOVA address is not required */
 450         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 451         digest_ptr.va = (void *)sop->aead.digest.data;
 452         aad_ptr.va = (void *)sop->aead.aad.data;
 453
 454         ofs.raw = 0;
 455
 456         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 457                 &symvec);
 458
 459         if (n != 1)
 460                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 461         else
 462                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 463 }
 464
 465 static void
 466 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 467 {
 468         int32_t n, st;
 469         struct rte_crypto_sym_op *sop;
 470         union rte_crypto_sym_ofs ofs;
 471         struct rte_crypto_sgl sgl;
 472         struct rte_crypto_sym_vec symvec;
 473         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 474         struct rte_crypto_vec vec[UINT8_MAX];
 475
 476         sop = op->sym;
 477
 478         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 479                 sop->auth.data.length, vec, RTE_DIM(vec));
 480
 481         if (n < 0 || n != sop->m_src->nb_segs) {
 482                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 483                 return;
 484         }
 485
 486         sgl.vec = vec;
 487         sgl.num = n;
 488         symvec.src_sgl = &sgl;
 489         symvec.iv = &iv_ptr;
 490         symvec.digest = &digest_ptr;
 491         symvec.status = &st;
 492         symvec.num = 1;
 493
 494         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 495         digest_ptr.va = (void *)sop->auth.digest.data;
 496
 497         ofs.raw = 0;
 498         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 499         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 500                 (sop->cipher.data.offset + sop->cipher.data.length);
 501
 502         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 503                 &symvec);
 504
 505         if (n != 1)
 506                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 507         else
 508                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 509 }
 510
 511 static struct rte_crypto_op *
 512 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 513 {
 514
 515         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 516
 517         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 518                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 519                 return NULL;
 520         }
 521
 522         op = NULL;
 523
 524         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 525                 rte_pause();
 526
 527         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 528                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 529                 return NULL;
 530         }
 531
 532         return op;
 533 }
 534
 535 static int
 536 testsuite_setup(void)
 537 {
 538         struct crypto_testsuite_params *ts_params = &testsuite_params;
 539         struct rte_cryptodev_info info;
 540         uint32_t i = 0, nb_devs, dev_id;
 541         uint16_t qp_id;
 542
 543         memset(ts_params, 0, sizeof(*ts_params));
 544
 545         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 546         if (ts_params->mbuf_pool == NULL) {
 547                 /* Not already created so create */
 548                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 549                                 "CRYPTO_MBUFPOOL",
 550                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 551                                 rte_socket_id());
 552                 if (ts_params->mbuf_pool == NULL) {
 553                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 554                         return TEST_FAILED;
 555                 }
 556         }
 557
 558         ts_params->large_mbuf_pool = rte_mempool_lookup(
 559                         "CRYPTO_LARGE_MBUFPOOL");
 560         if (ts_params->large_mbuf_pool == NULL) {
 561                 /* Not already created so create */
 562                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 563                                 "CRYPTO_LARGE_MBUFPOOL",
 564                                 1, 0, 0, UINT16_MAX,
 565                                 rte_socket_id());
 566                 if (ts_params->large_mbuf_pool == NULL) {
 567                         RTE_LOG(ERR, USER1,
 568                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 569                         return TEST_FAILED;
 570                 }
 571         }
 572
 573         ts_params->op_mpool = rte_crypto_op_pool_create(
 574                         "MBUF_CRYPTO_SYM_OP_POOL",
 575                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 576                         NUM_MBUFS, MBUF_CACHE_SIZE,
 577                         DEFAULT_NUM_XFORMS *
 578                         sizeof(struct rte_crypto_sym_xform) +
 579                         MAXIMUM_IV_LENGTH,
 580                         rte_socket_id());
 581         if (ts_params->op_mpool == NULL) {
 582                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 583                 return TEST_FAILED;
 584         }
 585
 586         nb_devs = rte_cryptodev_count();
 587         if (nb_devs < 1) {
 588                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 589                 return TEST_SKIPPED;
 590         }
 591
 592         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 593                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 594                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 595                 return TEST_SKIPPED;
 596         }
 597
 598         /* Create list of valid crypto devs */
 599         for (i = 0; i < nb_devs; i++) {
 600                 rte_cryptodev_info_get(i, &info);
 601                 if (info.driver_id == gbl_driver_id)
 602                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 603         }
 604
 605         if (ts_params->valid_dev_count < 1)
 606                 return TEST_FAILED;
 607
 608         /* Set up all the qps on the first of the valid devices found */
 609
 610         dev_id = ts_params->valid_devs[0];
 611
 612         rte_cryptodev_info_get(dev_id, &info);
 613
 614         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 615         ts_params->conf.socket_id = SOCKET_ID_ANY;
 616         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 617
 618         unsigned int session_size =
 619                 rte_cryptodev_sym_get_private_session_size(dev_id);
 620
 621 #ifdef RTE_LIB_SECURITY
 622         unsigned int security_session_size = rte_security_session_get_size(
 623                         rte_cryptodev_get_sec_ctx(dev_id));
 624
 625         if (session_size < security_session_size)
 626                 session_size = security_session_size;
 627 #endif
 628         /*
 629          * Create mempool with maximum number of sessions.
 630          */
 631         if (info.sym.max_nb_sessions != 0 &&
 632                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 633                 RTE_LOG(ERR, USER1, "Device does not support "
 634                                 "at least %u sessions\n",
 635                                 MAX_NB_SESSIONS);
 636                 return TEST_FAILED;
 637         }
 638
 639         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 640                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 641                         SOCKET_ID_ANY);
 642         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 643                         "session mempool allocation failed");
 644
 645         ts_params->session_priv_mpool = rte_mempool_create(
 646                         "test_sess_mp_priv",
 647                         MAX_NB_SESSIONS,
 648                         session_size,
 649                         0, 0, NULL, NULL, NULL,
 650                         NULL, SOCKET_ID_ANY,
 651                         0);
 652         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 653                         "session mempool allocation failed");
 654
 655
 656
 657         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 658                         &ts_params->conf),
 659                         "Failed to configure cryptodev %u with %u qps",
 660                         dev_id, ts_params->conf.nb_queue_pairs);
 661
 662         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 663         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 664         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 665
 666         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 667                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 668                         dev_id, qp_id, &ts_params->qp_conf,
 669                         rte_cryptodev_socket_id(dev_id)),
 670                         "Failed to setup queue pair %u on cryptodev %u",
 671                         qp_id, dev_id);
 672         }
 673
 674         return TEST_SUCCESS;
 675 }
 676
 677 static void
 678 testsuite_teardown(void)
 679 {
 680         struct crypto_testsuite_params *ts_params = &testsuite_params;
 681         int res;
 682
 683         if (ts_params->mbuf_pool != NULL) {
 684                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 685                 rte_mempool_avail_count(ts_params->mbuf_pool));
 686         }
 687
 688         if (ts_params->op_mpool != NULL) {
 689                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 690                 rte_mempool_avail_count(ts_params->op_mpool));
 691         }
 692
 693         /* Free session mempools */
 694         if (ts_params->session_priv_mpool != NULL) {
 695                 rte_mempool_free(ts_params->session_priv_mpool);
 696                 ts_params->session_priv_mpool = NULL;
 697         }
 698
 699         if (ts_params->session_mpool != NULL) {
 700                 rte_mempool_free(ts_params->session_mpool);
 701                 ts_params->session_mpool = NULL;
 702         }
 703
 704         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 705         if (res)
 706                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 707 }
 708
 709 static int
 710 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 711                 const int *algs, uint16_t num_algs)
 712 {
 713         uint8_t dev_id = testsuite_params.valid_devs[0];
 714         bool some_alg_supported = FALSE;
 715         uint16_t i;
 716
 717         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 718                 struct rte_cryptodev_sym_capability_idx alg = {
 719                         type, {algs[i]}
 720                 };
 721                 if (rte_cryptodev_sym_capability_get(dev_id,
 722                                 &alg) != NULL)
 723                         some_alg_supported = TRUE;
 724         }
 725         if (!some_alg_supported)
 726                 return TEST_SKIPPED;
 727
 728         return 0;
 729 }
 730
 731 int
 732 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 733                 uint16_t num_ciphers)
 734 {
 735         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 736                         (const int *) ciphers, num_ciphers);
 737 }
 738
 739 int
 740 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 741                 uint16_t num_auths)
 742 {
 743         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 744                         (const int *) auths, num_auths);
 745 }
 746
 747 int
 748 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 749                 uint16_t num_aeads)
 750 {
 751         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 752                         (const int *) aeads, num_aeads);
 753 }
 754
 755 static int
 756 null_testsuite_setup(void)
 757 {
 758         struct crypto_testsuite_params *ts_params = &testsuite_params;
 759         uint8_t dev_id = ts_params->valid_devs[0];
 760         struct rte_cryptodev_info dev_info;
 761         const enum rte_crypto_cipher_algorithm ciphers[] = {
 762                 RTE_CRYPTO_CIPHER_NULL
 763         };
 764         const enum rte_crypto_auth_algorithm auths[] = {
 765                 RTE_CRYPTO_AUTH_NULL
 766         };
 767
 768         rte_cryptodev_info_get(dev_id, &dev_info);
 769
 770         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 771                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 772                                 "testsuite not met\n");
 773                 return TEST_SKIPPED;
 774         }
 775
 776         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 777                         && check_auth_capabilities_supported(auths,
 778                         RTE_DIM(auths)) != 0) {
 779                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 780                                 "testsuite not met\n");
 781                 return TEST_SKIPPED;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static int
 788 crypto_gen_testsuite_setup(void)
 789 {
 790         struct crypto_testsuite_params *ts_params = &testsuite_params;
 791         uint8_t dev_id = ts_params->valid_devs[0];
 792         struct rte_cryptodev_info dev_info;
 793
 794         rte_cryptodev_info_get(dev_id, &dev_info);
 795
 796         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 797                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 798                                 "testsuite not met\n");
 799                 return TEST_SKIPPED;
 800         }
 801
 802         return 0;
 803 }
 804
 805 #ifdef RTE_LIB_SECURITY
 806 static int
 807 ipsec_proto_testsuite_setup(void)
 808 {
 809         struct crypto_testsuite_params *ts_params = &testsuite_params;
 810         struct crypto_unittest_params *ut_params = &unittest_params;
 811         struct rte_cryptodev_info dev_info;
 812         int ret = 0;
 813
 814         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 815
 816         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 817                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 818                                 "testsuite not met\n");
 819                 return TEST_SKIPPED;
 820         }
 821
 822         /* Reconfigure to enable security */
 823         ret = dev_configure_and_start(0);
 824         if (ret != TEST_SUCCESS)
 825                 return ret;
 826
 827         /* Set action type */
 828         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 829
 830         if (security_proto_supported(
 831                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 832                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 833                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 834                                 "test not met\n");
 835                 ret = TEST_SKIPPED;
 836         }
 837
 838         test_ipsec_alg_list_populate();
 839
 840         /*
 841          * Stop the device. Device would be started again by individual test
 842          * case setup routine.
 843          */
 844         rte_cryptodev_stop(ts_params->valid_devs[0]);
 845
 846         return ret;
 847 }
 848
 849 static int
 850 pdcp_proto_testsuite_setup(void)
 851 {
 852         struct crypto_testsuite_params *ts_params = &testsuite_params;
 853         uint8_t dev_id = ts_params->valid_devs[0];
 854         struct rte_cryptodev_info dev_info;
 855         const enum rte_crypto_cipher_algorithm ciphers[] = {
 856                 RTE_CRYPTO_CIPHER_NULL,
 857                 RTE_CRYPTO_CIPHER_AES_CTR,
 858                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 859                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 860         };
 861         const enum rte_crypto_auth_algorithm auths[] = {
 862                 RTE_CRYPTO_AUTH_NULL,
 863                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 864                 RTE_CRYPTO_AUTH_AES_CMAC,
 865                 RTE_CRYPTO_AUTH_ZUC_EIA3
 866         };
 867
 868         rte_cryptodev_info_get(dev_id, &dev_info);
 869
 870         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 871                         !(dev_info.feature_flags &
 872                         RTE_CRYPTODEV_FF_SECURITY)) {
 873                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 874                                 "testsuite not met\n");
 875                 return TEST_SKIPPED;
 876         }
 877
 878         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 879                         && check_auth_capabilities_supported(auths,
 880                         RTE_DIM(auths)) != 0) {
 881                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 882                                 "testsuite not met\n");
 883                 return TEST_SKIPPED;
 884         }
 885
 886         return 0;
 887 }
 888
 889 static int
 890 docsis_proto_testsuite_setup(void)
 891 {
 892         struct crypto_testsuite_params *ts_params = &testsuite_params;
 893         uint8_t dev_id = ts_params->valid_devs[0];
 894         struct rte_cryptodev_info dev_info;
 895         const enum rte_crypto_cipher_algorithm ciphers[] = {
 896                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 897         };
 898
 899         rte_cryptodev_info_get(dev_id, &dev_info);
 900
 901         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 902                         !(dev_info.feature_flags &
 903                         RTE_CRYPTODEV_FF_SECURITY)) {
 904                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 905                                 "Proto testsuite not met\n");
 906                 return TEST_SKIPPED;
 907         }
 908
 909         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 910                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 911                                 "testsuite not met\n");
 912                 return TEST_SKIPPED;
 913         }
 914
 915         return 0;
 916 }
 917 #endif
 918
 919 static int
 920 aes_ccm_auth_testsuite_setup(void)
 921 {
 922         struct crypto_testsuite_params *ts_params = &testsuite_params;
 923         uint8_t dev_id = ts_params->valid_devs[0];
 924         struct rte_cryptodev_info dev_info;
 925         const enum rte_crypto_aead_algorithm aeads[] = {
 926                 RTE_CRYPTO_AEAD_AES_CCM
 927         };
 928
 929         rte_cryptodev_info_get(dev_id, &dev_info);
 930
 931         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 932                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 933                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 934                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 935                                 "testsuite not met\n");
 936                 return TEST_SKIPPED;
 937         }
 938
 939         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 940                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 941                                 "testsuite not met\n");
 942                 return TEST_SKIPPED;
 943         }
 944
 945         return 0;
 946 }
 947
 948 static int
 949 aes_gcm_auth_testsuite_setup(void)
 950 {
 951         struct crypto_testsuite_params *ts_params = &testsuite_params;
 952         uint8_t dev_id = ts_params->valid_devs[0];
 953         struct rte_cryptodev_info dev_info;
 954         const enum rte_crypto_aead_algorithm aeads[] = {
 955                 RTE_CRYPTO_AEAD_AES_GCM
 956         };
 957
 958         rte_cryptodev_info_get(dev_id, &dev_info);
 959
 960         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 961                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 962                                 "testsuite not met\n");
 963                 return TEST_SKIPPED;
 964         }
 965
 966         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 967                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 968                                 "testsuite not met\n");
 969                 return TEST_SKIPPED;
 970         }
 971
 972         return 0;
 973 }
 974
 975 static int
 976 aes_gmac_auth_testsuite_setup(void)
 977 {
 978         struct crypto_testsuite_params *ts_params = &testsuite_params;
 979         uint8_t dev_id = ts_params->valid_devs[0];
 980         struct rte_cryptodev_info dev_info;
 981         const enum rte_crypto_auth_algorithm auths[] = {
 982                 RTE_CRYPTO_AUTH_AES_GMAC
 983         };
 984
 985         rte_cryptodev_info_get(dev_id, &dev_info);
 986
 987         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 988                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 989                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 990                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
 991                                 "testsuite not met\n");
 992                 return TEST_SKIPPED;
 993         }
 994
 995         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
 996                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
 997                                 "testsuite not met\n");
 998                 return TEST_SKIPPED;
 999         }
1000
1001         return 0;
1002 }
1003
1004 static int
1005 chacha20_poly1305_testsuite_setup(void)
1006 {
1007         struct crypto_testsuite_params *ts_params = &testsuite_params;
1008         uint8_t dev_id = ts_params->valid_devs[0];
1009         struct rte_cryptodev_info dev_info;
1010         const enum rte_crypto_aead_algorithm aeads[] = {
1011                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1012         };
1013
1014         rte_cryptodev_info_get(dev_id, &dev_info);
1015
1016         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1017                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1018                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1019                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1020                                 "Chacha20-Poly1305 testsuite not met\n");
1021                 return TEST_SKIPPED;
1022         }
1023
1024         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1025                 RTE_LOG(INFO, USER1, "Capability requirements for "
1026                                 "Chacha20-Poly1305 testsuite not met\n");
1027                 return TEST_SKIPPED;
1028         }
1029
1030         return 0;
1031 }
1032
1033 static int
1034 snow3g_testsuite_setup(void)
1035 {
1036         struct crypto_testsuite_params *ts_params = &testsuite_params;
1037         uint8_t dev_id = ts_params->valid_devs[0];
1038         struct rte_cryptodev_info dev_info;
1039         const enum rte_crypto_cipher_algorithm ciphers[] = {
1040                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1041
1042         };
1043         const enum rte_crypto_auth_algorithm auths[] = {
1044                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1045         };
1046
1047         rte_cryptodev_info_get(dev_id, &dev_info);
1048
1049         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1050                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1051                                 "testsuite not met\n");
1052                 return TEST_SKIPPED;
1053         }
1054
1055         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1056                         && check_auth_capabilities_supported(auths,
1057                         RTE_DIM(auths)) != 0) {
1058                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1059                                 "testsuite not met\n");
1060                 return TEST_SKIPPED;
1061         }
1062
1063         return 0;
1064 }
1065
1066 static int
1067 zuc_testsuite_setup(void)
1068 {
1069         struct crypto_testsuite_params *ts_params = &testsuite_params;
1070         uint8_t dev_id = ts_params->valid_devs[0];
1071         struct rte_cryptodev_info dev_info;
1072         const enum rte_crypto_cipher_algorithm ciphers[] = {
1073                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1074         };
1075         const enum rte_crypto_auth_algorithm auths[] = {
1076                 RTE_CRYPTO_AUTH_ZUC_EIA3
1077         };
1078
1079         rte_cryptodev_info_get(dev_id, &dev_info);
1080
1081         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1082                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1083                                 "testsuite not met\n");
1084                 return TEST_SKIPPED;
1085         }
1086
1087         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1088                         && check_auth_capabilities_supported(auths,
1089                         RTE_DIM(auths)) != 0) {
1090                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1091                                 "testsuite not met\n");
1092                 return TEST_SKIPPED;
1093         }
1094
1095         return 0;
1096 }
1097
1098 static int
1099 hmac_md5_auth_testsuite_setup(void)
1100 {
1101         struct crypto_testsuite_params *ts_params = &testsuite_params;
1102         uint8_t dev_id = ts_params->valid_devs[0];
1103         struct rte_cryptodev_info dev_info;
1104         const enum rte_crypto_auth_algorithm auths[] = {
1105                 RTE_CRYPTO_AUTH_MD5_HMAC
1106         };
1107
1108         rte_cryptodev_info_get(dev_id, &dev_info);
1109
1110         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1111                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1112                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1113                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1114                                 "Auth testsuite not met\n");
1115                 return TEST_SKIPPED;
1116         }
1117
1118         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1119                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1120                                 "testsuite not met\n");
1121                 return TEST_SKIPPED;
1122         }
1123
1124         return 0;
1125 }
1126
1127 static int
1128 kasumi_testsuite_setup(void)
1129 {
1130         struct crypto_testsuite_params *ts_params = &testsuite_params;
1131         uint8_t dev_id = ts_params->valid_devs[0];
1132         struct rte_cryptodev_info dev_info;
1133         const enum rte_crypto_cipher_algorithm ciphers[] = {
1134                 RTE_CRYPTO_CIPHER_KASUMI_F8
1135         };
1136         const enum rte_crypto_auth_algorithm auths[] = {
1137                 RTE_CRYPTO_AUTH_KASUMI_F9
1138         };
1139
1140         rte_cryptodev_info_get(dev_id, &dev_info);
1141
1142         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1143                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1144                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1145                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1146                                 "testsuite not met\n");
1147                 return TEST_SKIPPED;
1148         }
1149
1150         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1151                         && check_auth_capabilities_supported(auths,
1152                         RTE_DIM(auths)) != 0) {
1153                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1154                                 "testsuite not met\n");
1155                 return TEST_SKIPPED;
1156         }
1157
1158         return 0;
1159 }
1160
1161 static int
1162 negative_aes_gcm_testsuite_setup(void)
1163 {
1164         struct crypto_testsuite_params *ts_params = &testsuite_params;
1165         uint8_t dev_id = ts_params->valid_devs[0];
1166         struct rte_cryptodev_info dev_info;
1167         const enum rte_crypto_aead_algorithm aeads[] = {
1168                 RTE_CRYPTO_AEAD_AES_GCM
1169         };
1170
1171         rte_cryptodev_info_get(dev_id, &dev_info);
1172
1173         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1174                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1175                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1176                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1177                                 "AES GCM testsuite not met\n");
1178                 return TEST_SKIPPED;
1179         }
1180
1181         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1182                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1183                                 "AES GCM testsuite not met\n");
1184                 return TEST_SKIPPED;
1185         }
1186
1187         return 0;
1188 }
1189
1190 static int
1191 negative_aes_gmac_testsuite_setup(void)
1192 {
1193         struct crypto_testsuite_params *ts_params = &testsuite_params;
1194         uint8_t dev_id = ts_params->valid_devs[0];
1195         struct rte_cryptodev_info dev_info;
1196         const enum rte_crypto_auth_algorithm auths[] = {
1197                 RTE_CRYPTO_AUTH_AES_GMAC
1198         };
1199
1200         rte_cryptodev_info_get(dev_id, &dev_info);
1201
1202         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1203                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1204                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1205                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1206                                 "AES GMAC testsuite not met\n");
1207                 return TEST_SKIPPED;
1208         }
1209
1210         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1211                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1212                                 "AES GMAC testsuite not met\n");
1213                 return TEST_SKIPPED;
1214         }
1215
1216         return 0;
1217 }
1218
1219 static int
1220 mixed_cipher_hash_testsuite_setup(void)
1221 {
1222         struct crypto_testsuite_params *ts_params = &testsuite_params;
1223         uint8_t dev_id = ts_params->valid_devs[0];
1224         struct rte_cryptodev_info dev_info;
1225         uint64_t feat_flags;
1226         const enum rte_crypto_cipher_algorithm ciphers[] = {
1227                 RTE_CRYPTO_CIPHER_NULL,
1228                 RTE_CRYPTO_CIPHER_AES_CTR,
1229                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1230                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1231         };
1232         const enum rte_crypto_auth_algorithm auths[] = {
1233                 RTE_CRYPTO_AUTH_NULL,
1234                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1235                 RTE_CRYPTO_AUTH_AES_CMAC,
1236                 RTE_CRYPTO_AUTH_ZUC_EIA3
1237         };
1238
1239         rte_cryptodev_info_get(dev_id, &dev_info);
1240         feat_flags = dev_info.feature_flags;
1241
1242         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1243                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1244                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1245                                 "Cipher Hash testsuite not met\n");
1246                 return TEST_SKIPPED;
1247         }
1248
1249         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1250                         && check_auth_capabilities_supported(auths,
1251                         RTE_DIM(auths)) != 0) {
1252                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1253                                 "Cipher Hash testsuite not met\n");
1254                 return TEST_SKIPPED;
1255         }
1256
1257         return 0;
1258 }
1259
1260 static int
1261 esn_testsuite_setup(void)
1262 {
1263         struct crypto_testsuite_params *ts_params = &testsuite_params;
1264         uint8_t dev_id = ts_params->valid_devs[0];
1265         struct rte_cryptodev_info dev_info;
1266         const enum rte_crypto_cipher_algorithm ciphers[] = {
1267                 RTE_CRYPTO_CIPHER_AES_CBC
1268         };
1269         const enum rte_crypto_auth_algorithm auths[] = {
1270                 RTE_CRYPTO_AUTH_SHA1_HMAC
1271         };
1272
1273         rte_cryptodev_info_get(dev_id, &dev_info);
1274
1275         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1276                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1277                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1278                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1279                                 "testsuite not met\n");
1280                 return TEST_SKIPPED;
1281         }
1282
1283         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1284                         && check_auth_capabilities_supported(auths,
1285                         RTE_DIM(auths)) != 0) {
1286                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1287                                 "testsuite not met\n");
1288                 return TEST_SKIPPED;
1289         }
1290
1291         return 0;
1292 }
1293
1294 static int
1295 multi_session_testsuite_setup(void)
1296 {
1297         struct crypto_testsuite_params *ts_params = &testsuite_params;
1298         uint8_t dev_id = ts_params->valid_devs[0];
1299         struct rte_cryptodev_info dev_info;
1300         const enum rte_crypto_cipher_algorithm ciphers[] = {
1301                 RTE_CRYPTO_CIPHER_AES_CBC
1302         };
1303         const enum rte_crypto_auth_algorithm auths[] = {
1304                 RTE_CRYPTO_AUTH_SHA512_HMAC
1305         };
1306
1307         rte_cryptodev_info_get(dev_id, &dev_info);
1308
1309         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1310                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1311                                 "Session testsuite not met\n");
1312                 return TEST_SKIPPED;
1313         }
1314
1315         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1316                         && check_auth_capabilities_supported(auths,
1317                         RTE_DIM(auths)) != 0) {
1318                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1319                                 "Session testsuite not met\n");
1320                 return TEST_SKIPPED;
1321         }
1322
1323         return 0;
1324 }
1325
1326 static int
1327 negative_hmac_sha1_testsuite_setup(void)
1328 {
1329         struct crypto_testsuite_params *ts_params = &testsuite_params;
1330         uint8_t dev_id = ts_params->valid_devs[0];
1331         struct rte_cryptodev_info dev_info;
1332         const enum rte_crypto_cipher_algorithm ciphers[] = {
1333                 RTE_CRYPTO_CIPHER_AES_CBC
1334         };
1335         const enum rte_crypto_auth_algorithm auths[] = {
1336                 RTE_CRYPTO_AUTH_SHA1_HMAC
1337         };
1338
1339         rte_cryptodev_info_get(dev_id, &dev_info);
1340
1341         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1342                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1343                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1344                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1345                                 "HMAC SHA1 testsuite not met\n");
1346                 return TEST_SKIPPED;
1347         }
1348
1349         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1350                         && check_auth_capabilities_supported(auths,
1351                         RTE_DIM(auths)) != 0) {
1352                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1353                                 "HMAC SHA1 testsuite not met\n");
1354                 return TEST_SKIPPED;
1355         }
1356
1357         return 0;
1358 }
1359
1360 static int
1361 dev_configure_and_start(uint64_t ff_disable)
1362 {
1363         struct crypto_testsuite_params *ts_params = &testsuite_params;
1364         struct crypto_unittest_params *ut_params = &unittest_params;
1365
1366         uint16_t qp_id;
1367
1368         /* Clear unit test parameters before running test */
1369         memset(ut_params, 0, sizeof(*ut_params));
1370
1371         /* Reconfigure device to default parameters */
1372         ts_params->conf.socket_id = SOCKET_ID_ANY;
1373         ts_params->conf.ff_disable = ff_disable;
1374         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1375         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1376         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1377
1378         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1379                         &ts_params->conf),
1380                         "Failed to configure cryptodev %u",
1381                         ts_params->valid_devs[0]);
1382
1383         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1384                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1385                         ts_params->valid_devs[0], qp_id,
1386                         &ts_params->qp_conf,
1387                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1388                         "Failed to setup queue pair %u on cryptodev %u",
1389                         qp_id, ts_params->valid_devs[0]);
1390         }
1391
1392
1393         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1394
1395         /* Start the device */
1396         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1397                         "Failed to start cryptodev %u",
1398                         ts_params->valid_devs[0]);
1399
1400         return TEST_SUCCESS;
1401 }
1402
1403 int
1404 ut_setup(void)
1405 {
1406         /* Configure and start the device with security feature disabled */
1407         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1408 }
1409
1410 static int
1411 ut_setup_security(void)
1412 {
1413         /* Configure and start the device with no features disabled */
1414         return dev_configure_and_start(0);
1415 }
1416
1417 void
1418 ut_teardown(void)
1419 {
1420         struct crypto_testsuite_params *ts_params = &testsuite_params;
1421         struct crypto_unittest_params *ut_params = &unittest_params;
1422
1423         /* free crypto session structure */
1424 #ifdef RTE_LIB_SECURITY
1425         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1426                 if (ut_params->sec_session) {
1427                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1428                                                 (ts_params->valid_devs[0]),
1429                                                 ut_params->sec_session);
1430                         ut_params->sec_session = NULL;
1431                 }
1432         } else
1433 #endif
1434         {
1435                 if (ut_params->sess) {
1436                         rte_cryptodev_sym_session_clear(
1437                                         ts_params->valid_devs[0],
1438                                         ut_params->sess);
1439                         rte_cryptodev_sym_session_free(ut_params->sess);
1440                         ut_params->sess = NULL;
1441                 }
1442         }
1443
1444         /* free crypto operation structure */
1445         if (ut_params->op)
1446                 rte_crypto_op_free(ut_params->op);
1447
1448         /*
1449          * free mbuf - both obuf and ibuf are usually the same,
1450          * so check if they point at the same address is necessary,
1451          * to avoid freeing the mbuf twice.
1452          */
1453         if (ut_params->obuf) {
1454                 rte_pktmbuf_free(ut_params->obuf);
1455                 if (ut_params->ibuf == ut_params->obuf)
1456                         ut_params->ibuf = 0;
1457                 ut_params->obuf = 0;
1458         }
1459         if (ut_params->ibuf) {
1460                 rte_pktmbuf_free(ut_params->ibuf);
1461                 ut_params->ibuf = 0;
1462         }
1463
1464         if (ts_params->mbuf_pool != NULL)
1465                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1466                         rte_mempool_avail_count(ts_params->mbuf_pool));
1467
1468         /* Stop the device */
1469         rte_cryptodev_stop(ts_params->valid_devs[0]);
1470 }
1471
1472 static int
1473 test_device_configure_invalid_dev_id(void)
1474 {
1475         struct crypto_testsuite_params *ts_params = &testsuite_params;
1476         uint16_t dev_id, num_devs = 0;
1477
1478         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1479                         "Need at least %d devices for test", 1);
1480
1481         /* valid dev_id values */
1482         dev_id = ts_params->valid_devs[0];
1483
1484         /* Stop the device in case it's started so it can be configured */
1485         rte_cryptodev_stop(dev_id);
1486
1487         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1488                         "Failed test for rte_cryptodev_configure: "
1489                         "invalid dev_num %u", dev_id);
1490
1491         /* invalid dev_id values */
1492         dev_id = num_devs;
1493
1494         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1495                         "Failed test for rte_cryptodev_configure: "
1496                         "invalid dev_num %u", dev_id);
1497
1498         dev_id = 0xff;
1499
1500         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1501                         "Failed test for rte_cryptodev_configure:"
1502                         "invalid dev_num %u", dev_id);
1503
1504         return TEST_SUCCESS;
1505 }
1506
1507 static int
1508 test_device_configure_invalid_queue_pair_ids(void)
1509 {
1510         struct crypto_testsuite_params *ts_params = &testsuite_params;
1511         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1512
1513         /* Stop the device in case it's started so it can be configured */
1514         rte_cryptodev_stop(ts_params->valid_devs[0]);
1515
1516         /* valid - max value queue pairs */
1517         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1518
1519         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1520                         &ts_params->conf),
1521                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1522                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1523
1524         /* valid - one queue pairs */
1525         ts_params->conf.nb_queue_pairs = 1;
1526
1527         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1528                         &ts_params->conf),
1529                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1530                         ts_params->valid_devs[0],
1531                         ts_params->conf.nb_queue_pairs);
1532
1533
1534         /* invalid - zero queue pairs */
1535         ts_params->conf.nb_queue_pairs = 0;
1536
1537         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1538                         &ts_params->conf),
1539                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1540                         " invalid qps: %u",
1541                         ts_params->valid_devs[0],
1542                         ts_params->conf.nb_queue_pairs);
1543
1544
1545         /* invalid - max value supported by field queue pairs */
1546         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1547
1548         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1549                         &ts_params->conf),
1550                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1551                         " invalid qps: %u",
1552                         ts_params->valid_devs[0],
1553                         ts_params->conf.nb_queue_pairs);
1554
1555
1556         /* invalid - max value + 1 queue pairs */
1557         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1558
1559         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1560                         &ts_params->conf),
1561                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1562                         " invalid qps: %u",
1563                         ts_params->valid_devs[0],
1564                         ts_params->conf.nb_queue_pairs);
1565
1566         /* revert to original testsuite value */
1567         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1568
1569         return TEST_SUCCESS;
1570 }
1571
1572 static int
1573 test_queue_pair_descriptor_setup(void)
1574 {
1575         struct crypto_testsuite_params *ts_params = &testsuite_params;
1576         struct rte_cryptodev_qp_conf qp_conf = {
1577                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1578         };
1579         uint16_t qp_id;
1580
1581         /* Stop the device in case it's started so it can be configured */
1582         rte_cryptodev_stop(ts_params->valid_devs[0]);
1583
1584         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1585                         &ts_params->conf),
1586                         "Failed to configure cryptodev %u",
1587                         ts_params->valid_devs[0]);
1588
1589         /*
1590          * Test various ring sizes on this device. memzones can't be
1591          * freed so are re-used if ring is released and re-created.
1592          */
1593         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1594         qp_conf.mp_session = ts_params->session_mpool;
1595         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1596
1597         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1598                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1599                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1600                                 rte_cryptodev_socket_id(
1601                                                 ts_params->valid_devs[0])),
1602                                 "Failed test for "
1603                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1604                                 "%u on qp %u on cryptodev %u",
1605                                 qp_conf.nb_descriptors, qp_id,
1606                                 ts_params->valid_devs[0]);
1607         }
1608
1609         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1610
1611         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1612                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1613                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1614                                 rte_cryptodev_socket_id(
1615                                                 ts_params->valid_devs[0])),
1616                                 "Failed test for"
1617                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1618                                 " %u on qp %u on cryptodev %u",
1619                                 qp_conf.nb_descriptors, qp_id,
1620                                 ts_params->valid_devs[0]);
1621         }
1622
1623         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1624
1625         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1626                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1627                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1628                                 rte_cryptodev_socket_id(
1629                                                 ts_params->valid_devs[0])),
1630                                 "Failed test for "
1631                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1632                                 " %u on qp %u on cryptodev %u",
1633                                 qp_conf.nb_descriptors, qp_id,
1634                                 ts_params->valid_devs[0]);
1635         }
1636
1637         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1638
1639         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1640                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1641                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1642                                 rte_cryptodev_socket_id(
1643                                                 ts_params->valid_devs[0])),
1644                                 "Failed test for"
1645                                 " rte_cryptodev_queue_pair_setup:"
1646                                 "num_inflights %u on qp %u on cryptodev %u",
1647                                 qp_conf.nb_descriptors, qp_id,
1648                                 ts_params->valid_devs[0]);
1649         }
1650
1651         /* test invalid queue pair id */
1652         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1653
1654         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1655
1656         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1657                         ts_params->valid_devs[0],
1658                         qp_id, &qp_conf,
1659                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1660                         "Failed test for rte_cryptodev_queue_pair_setup:"
1661                         "invalid qp %u on cryptodev %u",
1662                         qp_id, ts_params->valid_devs[0]);
1663
1664         qp_id = 0xffff; /*invalid*/
1665
1666         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1667                         ts_params->valid_devs[0],
1668                         qp_id, &qp_conf,
1669                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1670                         "Failed test for rte_cryptodev_queue_pair_setup:"
1671                         "invalid qp %u on cryptodev %u",
1672                         qp_id, ts_params->valid_devs[0]);
1673
1674         return TEST_SUCCESS;
1675 }
1676
1677 /* ***** Plaintext data for tests ***** */
1678
1679 const char catch_22_quote_1[] =
1680                 "There was only one catch and that was Catch-22, which "
1681                 "specified that a concern for one's safety in the face of "
1682                 "dangers that were real and immediate was the process of a "
1683                 "rational mind. Orr was crazy and could be grounded. All he "
1684                 "had to do was ask; and as soon as he did, he would no longer "
1685                 "be crazy and would have to fly more missions. Orr would be "
1686                 "crazy to fly more missions and sane if he didn't, but if he "
1687                 "was sane he had to fly them. If he flew them he was crazy "
1688                 "and didn't have to; but if he didn't want to he was sane and "
1689                 "had to. Yossarian was moved very deeply by the absolute "
1690                 "simplicity of this clause of Catch-22 and let out a "
1691                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1692                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1693
1694 const char catch_22_quote[] =
1695                 "What a lousy earth! He wondered how many people were "
1696                 "destitute that same night even in his own prosperous country, "
1697                 "how many homes were shanties, how many husbands were drunk "
1698                 "and wives socked, and how many children were bullied, abused, "
1699                 "or abandoned. How many families hungered for food they could "
1700                 "not afford to buy? How many hearts were broken? How many "
1701                 "suicides would take place that same night, how many people "
1702                 "would go insane? How many cockroaches and landlords would "
1703                 "triumph? How many winners were losers, successes failures, "
1704                 "and rich men poor men? How many wise guys were stupid? How "
1705                 "many happy endings were unhappy endings? How many honest men "
1706                 "were liars, brave men cowards, loyal men traitors, how many "
1707                 "sainted men were corrupt, how many people in positions of "
1708                 "trust had sold their souls to bodyguards, how many had never "
1709                 "had souls? How many straight-and-narrow paths were crooked "
1710                 "paths? How many best families were worst families and how "
1711                 "many good people were bad people? When you added them all up "
1712                 "and then subtracted, you might be left with only the children, "
1713                 "and perhaps with Albert Einstein and an old violinist or "
1714                 "sculptor somewhere.";
1715
1716 #define QUOTE_480_BYTES         (480)
1717 #define QUOTE_512_BYTES         (512)
1718 #define QUOTE_768_BYTES         (768)
1719 #define QUOTE_1024_BYTES        (1024)
1720
1721
1722
1723 /* ***** SHA1 Hash Tests ***** */
1724
1725 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1726
1727 static uint8_t hmac_sha1_key[] = {
1728         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1729         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1730         0xDE, 0xF4, 0xDE, 0xAD };
1731
1732 /* ***** SHA224 Hash Tests ***** */
1733
1734 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1735
1736
1737 /* ***** AES-CBC Cipher Tests ***** */
1738
1739 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1740 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1741
1742 static uint8_t aes_cbc_key[] = {
1743         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1744         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1745
1746 static uint8_t aes_cbc_iv[] = {
1747         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1748         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1749
1750
1751 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1752
1753 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1754         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1755         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1756         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1757         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1758         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1759         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1760         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1761         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1762         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1763         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1764         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1765         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1766         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1767         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1768         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1769         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1770         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1771         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1772         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1773         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1774         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1775         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1776         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1777         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1778         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1779         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1780         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1781         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1782         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1783         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1784         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1785         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1786         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1787         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1788         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1789         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1790         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1791         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1792         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1793         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1794         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1795         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1796         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1797         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1798         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1799         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1800         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1801         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1802         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1803         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1804         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1805         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1806         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1807         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1808         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1809         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1810         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1811         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1812         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1813         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1814         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1815         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1816         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1817         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1818 };
1819
1820 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1821         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1822         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1823         0x18, 0x8c, 0x1d, 0x32
1824 };
1825
1826
1827 /* Multisession Vector context Test */
1828 /*Begin Session 0 */
1829 static uint8_t ms_aes_cbc_key0[] = {
1830         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1831         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1832 };
1833
1834 static uint8_t ms_aes_cbc_iv0[] = {
1835         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1836         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1837 };
1838
1839 static const uint8_t ms_aes_cbc_cipher0[] = {
1840                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1841                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1842                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1843                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1844                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1845                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1846                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1847                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1848                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1849                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1850                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1851                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1852                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1853                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1854                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1855                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1856                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1857                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1858                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1859                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1860                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1861                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1862                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1863                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1864                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1865                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1866                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1867                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1868                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1869                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1870                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1871                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1872                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1873                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1874                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1875                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1876                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1877                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1878                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1879                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1880                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1881                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1882                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1883                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1884                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1885                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1886                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1887                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1888                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1889                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1890                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1891                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1892                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1893                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1894                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1895                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1896                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1897                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1898                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1899                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1900                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1901                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1902                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1903                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1904 };
1905
1906
1907 static  uint8_t ms_hmac_key0[] = {
1908                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1909                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1910                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1911                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1912                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1913                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1914                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1915                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1916 };
1917
1918 static const uint8_t ms_hmac_digest0[] = {
1919                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1920                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1921                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1922                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1923                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1924                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1925                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1926                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1927                 };
1928
1929 /* End Session 0 */
1930 /* Begin session 1 */
1931
1932 static  uint8_t ms_aes_cbc_key1[] = {
1933                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1934                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1935 };
1936
1937 static  uint8_t ms_aes_cbc_iv1[] = {
1938         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1939         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1940 };
1941
1942 static const uint8_t ms_aes_cbc_cipher1[] = {
1943                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1944                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1945                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1946                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1947                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1948                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1949                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1950                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1951                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1952                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1953                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1954                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1955                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1956                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1957                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1958                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1959                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1960                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1961                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1962                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1963                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1964                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1965                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1966                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1967                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1968                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1969                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1970                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1971                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1972                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1973                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1974                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1975                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1976                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1977                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1978                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1979                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1980                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1981                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1982                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1983                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1984                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1985                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1986                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1987                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1988                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1989                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1990                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
1991                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
1992                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
1993                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
1994                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
1995                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
1996                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
1997                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
1998                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
1999                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2000                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2001                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2002                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2003                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2004                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2005                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2006                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2007
2008 };
2009
2010 static uint8_t ms_hmac_key1[] = {
2011                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2012                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2013                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2014                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2015                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2016                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2017                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2018                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2019 };
2020
2021 static const uint8_t ms_hmac_digest1[] = {
2022                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2023                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2024                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2025                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2026                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2027                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2028                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2029                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2030 };
2031 /* End Session 1  */
2032 /* Begin Session 2 */
2033 static  uint8_t ms_aes_cbc_key2[] = {
2034                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2035                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2036 };
2037
2038 static  uint8_t ms_aes_cbc_iv2[] = {
2039                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2040                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2041 };
2042
2043 static const uint8_t ms_aes_cbc_cipher2[] = {
2044                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2045                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2046                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2047                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2048                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2049                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2050                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2051                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2052                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2053                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2054                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2055                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2056                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2057                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2058                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2059                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2060                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2061                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2062                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2063                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2064                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2065                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2066                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2067                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2068                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2069                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2070                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2071                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2072                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2073                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2074                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2075                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2076                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2077                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2078                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2079                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2080                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2081                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2082                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2083                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2084                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2085                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2086                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2087                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2088                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2089                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2090                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2091                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2092                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2093                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2094                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2095                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2096                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2097                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2098                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2099                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2100                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2101                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2102                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2103                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2104                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2105                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2106                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2107                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2108 };
2109
2110 static  uint8_t ms_hmac_key2[] = {
2111                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2112                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2113                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2114                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2115                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2116                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2117                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2118                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2119 };
2120
2121 static const uint8_t ms_hmac_digest2[] = {
2122                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2123                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2124                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2125                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2126                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2127                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2128                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2129                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2130 };
2131
2132 /* End Session 2 */
2133
2134
2135 static int
2136 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2137 {
2138         struct crypto_testsuite_params *ts_params = &testsuite_params;
2139         struct crypto_unittest_params *ut_params = &unittest_params;
2140         int status;
2141
2142         /* Verify the capabilities */
2143         struct rte_cryptodev_sym_capability_idx cap_idx;
2144         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2145         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2146         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2147                         &cap_idx) == NULL)
2148                 return TEST_SKIPPED;
2149         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2150         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2151         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2152                         &cap_idx) == NULL)
2153                 return TEST_SKIPPED;
2154
2155         /* Generate test mbuf data and space for digest */
2156         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2157                         catch_22_quote, QUOTE_512_BYTES, 0);
2158
2159         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2160                         DIGEST_BYTE_LENGTH_SHA1);
2161         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2162
2163         /* Setup Cipher Parameters */
2164         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2165         ut_params->cipher_xform.next = &ut_params->auth_xform;
2166
2167         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2168         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2169         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2170         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2171         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2172         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2173
2174         /* Setup HMAC Parameters */
2175         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2176
2177         ut_params->auth_xform.next = NULL;
2178
2179         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2180         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2181         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2182         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2183         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2184
2185         ut_params->sess = rte_cryptodev_sym_session_create(
2186                         ts_params->session_mpool);
2187         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2188
2189         /* Create crypto session*/
2190         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2191                         ut_params->sess, &ut_params->cipher_xform,
2192                         ts_params->session_priv_mpool);
2193
2194         if (status == -ENOTSUP)
2195                 return TEST_SKIPPED;
2196
2197         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2198
2199         /* Generate crypto op data structure */
2200         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2201                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2202         TEST_ASSERT_NOT_NULL(ut_params->op,
2203                         "Failed to allocate symmetric crypto operation struct");
2204
2205         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2206
2207         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2208
2209         /* set crypto operation source mbuf */
2210         sym_op->m_src = ut_params->ibuf;
2211
2212         /* Set crypto operation authentication parameters */
2213         sym_op->auth.digest.data = ut_params->digest;
2214         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2215                         ut_params->ibuf, QUOTE_512_BYTES);
2216
2217         sym_op->auth.data.offset = 0;
2218         sym_op->auth.data.length = QUOTE_512_BYTES;
2219
2220         /* Copy IV at the end of the crypto operation */
2221         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2222                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2223
2224         /* Set crypto operation cipher parameters */
2225         sym_op->cipher.data.offset = 0;
2226         sym_op->cipher.data.length = QUOTE_512_BYTES;
2227
2228         /* Process crypto operation */
2229         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2230                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2231                         ut_params->op);
2232         else
2233                 TEST_ASSERT_NOT_NULL(
2234                         process_crypto_request(ts_params->valid_devs[0],
2235                                 ut_params->op),
2236                                 "failed to process sym crypto op");
2237
2238         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2239                         "crypto op processing failed");
2240
2241         /* Validate obuf */
2242         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2243                         uint8_t *);
2244
2245         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2246                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2247                         QUOTE_512_BYTES,
2248                         "ciphertext data not as expected");
2249
2250         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2251
2252         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2253                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2254                         gbl_driver_id == rte_cryptodev_driver_id_get(
2255                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2256                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2257                                         DIGEST_BYTE_LENGTH_SHA1,
2258                         "Generated digest data not as expected");
2259
2260         return TEST_SUCCESS;
2261 }
2262
2263 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2264
2265 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2266
2267 static uint8_t hmac_sha512_key[] = {
2268         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2269         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2270         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2271         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2272         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2273         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2274         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2275         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2276
2277 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2278         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2279         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2280         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2281         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2282         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2283         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2284         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2285         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2286
2287
2288
2289 static int
2290 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2291                 struct crypto_unittest_params *ut_params,
2292                 uint8_t *cipher_key,
2293                 uint8_t *hmac_key);
2294
2295 static int
2296 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2297                 struct crypto_unittest_params *ut_params,
2298                 struct crypto_testsuite_params *ts_params,
2299                 const uint8_t *cipher,
2300                 const uint8_t *digest,
2301                 const uint8_t *iv);
2302
2303
2304 static int
2305 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2306                 struct crypto_unittest_params *ut_params,
2307                 uint8_t *cipher_key,
2308                 uint8_t *hmac_key)
2309 {
2310
2311         /* Setup Cipher Parameters */
2312         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2313         ut_params->cipher_xform.next = NULL;
2314
2315         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2316         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2317         ut_params->cipher_xform.cipher.key.data = cipher_key;
2318         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2319         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2320         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2321
2322         /* Setup HMAC Parameters */
2323         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2324         ut_params->auth_xform.next = &ut_params->cipher_xform;
2325
2326         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2327         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2328         ut_params->auth_xform.auth.key.data = hmac_key;
2329         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2330         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2331
2332         return TEST_SUCCESS;
2333 }
2334
2335
2336 static int
2337 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2338                 struct crypto_unittest_params *ut_params,
2339                 struct crypto_testsuite_params *ts_params,
2340                 const uint8_t *cipher,
2341                 const uint8_t *digest,
2342                 const uint8_t *iv)
2343 {
2344         /* Generate test mbuf data and digest */
2345         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2346                         (const char *)
2347                         cipher,
2348                         QUOTE_512_BYTES, 0);
2349
2350         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2351                         DIGEST_BYTE_LENGTH_SHA512);
2352         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2353
2354         rte_memcpy(ut_params->digest,
2355                         digest,
2356                         DIGEST_BYTE_LENGTH_SHA512);
2357
2358         /* Generate Crypto op data structure */
2359         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2360                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2361         TEST_ASSERT_NOT_NULL(ut_params->op,
2362                         "Failed to allocate symmetric crypto operation struct");
2363
2364         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2365
2366         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2367
2368         /* set crypto operation source mbuf */
2369         sym_op->m_src = ut_params->ibuf;
2370
2371         sym_op->auth.digest.data = ut_params->digest;
2372         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2373                         ut_params->ibuf, QUOTE_512_BYTES);
2374
2375         sym_op->auth.data.offset = 0;
2376         sym_op->auth.data.length = QUOTE_512_BYTES;
2377
2378         /* Copy IV at the end of the crypto operation */
2379         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2380                         iv, CIPHER_IV_LENGTH_AES_CBC);
2381
2382         sym_op->cipher.data.offset = 0;
2383         sym_op->cipher.data.length = QUOTE_512_BYTES;
2384
2385         /* Process crypto operation */
2386         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2387                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2388                         ut_params->op);
2389         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2390                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2391                                 ut_params->op, 1, 1, 0, 0);
2392         else
2393                 TEST_ASSERT_NOT_NULL(
2394                                 process_crypto_request(ts_params->valid_devs[0],
2395                                         ut_params->op),
2396                                         "failed to process sym crypto op");
2397
2398         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2399                         "crypto op processing failed");
2400
2401         ut_params->obuf = ut_params->op->sym->m_src;
2402
2403         /* Validate obuf */
2404         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2405                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2406                         catch_22_quote,
2407                         QUOTE_512_BYTES,
2408                         "Plaintext data not as expected");
2409
2410         /* Validate obuf */
2411         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2412                         "Digest verification failed");
2413
2414         return TEST_SUCCESS;
2415 }
2416
2417 /* ***** SNOW 3G Tests ***** */
2418 static int
2419 create_wireless_algo_hash_session(uint8_t dev_id,
2420         const uint8_t *key, const uint8_t key_len,
2421         const uint8_t iv_len, const uint8_t auth_len,
2422         enum rte_crypto_auth_operation op,
2423         enum rte_crypto_auth_algorithm algo)
2424 {
2425         uint8_t hash_key[key_len];
2426         int status;
2427
2428         struct crypto_testsuite_params *ts_params = &testsuite_params;
2429         struct crypto_unittest_params *ut_params = &unittest_params;
2430
2431         memcpy(hash_key, key, key_len);
2432
2433         debug_hexdump(stdout, "key:", key, key_len);
2434
2435         /* Setup Authentication Parameters */
2436         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2437         ut_params->auth_xform.next = NULL;
2438
2439         ut_params->auth_xform.auth.op = op;
2440         ut_params->auth_xform.auth.algo = algo;
2441         ut_params->auth_xform.auth.key.length = key_len;
2442         ut_params->auth_xform.auth.key.data = hash_key;
2443         ut_params->auth_xform.auth.digest_length = auth_len;
2444         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2445         ut_params->auth_xform.auth.iv.length = iv_len;
2446         ut_params->sess = rte_cryptodev_sym_session_create(
2447                         ts_params->session_mpool);
2448
2449         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2450                         &ut_params->auth_xform,
2451                         ts_params->session_priv_mpool);
2452         if (status == -ENOTSUP)
2453                 return TEST_SKIPPED;
2454
2455         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2456         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2457         return 0;
2458 }
2459
2460 static int
2461 create_wireless_algo_cipher_session(uint8_t dev_id,
2462                         enum rte_crypto_cipher_operation op,
2463                         enum rte_crypto_cipher_algorithm algo,
2464                         const uint8_t *key, const uint8_t key_len,
2465                         uint8_t iv_len)
2466 {
2467         uint8_t cipher_key[key_len];
2468         int status;
2469         struct crypto_testsuite_params *ts_params = &testsuite_params;
2470         struct crypto_unittest_params *ut_params = &unittest_params;
2471
2472         memcpy(cipher_key, key, key_len);
2473
2474         /* Setup Cipher Parameters */
2475         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2476         ut_params->cipher_xform.next = NULL;
2477
2478         ut_params->cipher_xform.cipher.algo = algo;
2479         ut_params->cipher_xform.cipher.op = op;
2480         ut_params->cipher_xform.cipher.key.data = cipher_key;
2481         ut_params->cipher_xform.cipher.key.length = key_len;
2482         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2483         ut_params->cipher_xform.cipher.iv.length = iv_len;
2484
2485         debug_hexdump(stdout, "key:", key, key_len);
2486
2487         /* Create Crypto session */
2488         ut_params->sess = rte_cryptodev_sym_session_create(
2489                         ts_params->session_mpool);
2490
2491         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2492                         &ut_params->cipher_xform,
2493                         ts_params->session_priv_mpool);
2494         if (status == -ENOTSUP)
2495                 return TEST_SKIPPED;
2496
2497         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2498         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2499         return 0;
2500 }
2501
2502 static int
2503 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2504                         unsigned int cipher_len,
2505                         unsigned int cipher_offset)
2506 {
2507         struct crypto_testsuite_params *ts_params = &testsuite_params;
2508         struct crypto_unittest_params *ut_params = &unittest_params;
2509
2510         /* Generate Crypto op data structure */
2511         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2512                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2513         TEST_ASSERT_NOT_NULL(ut_params->op,
2514                                 "Failed to allocate pktmbuf offload");
2515
2516         /* Set crypto operation data parameters */
2517         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2518
2519         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2520
2521         /* set crypto operation source mbuf */
2522         sym_op->m_src = ut_params->ibuf;
2523
2524         /* iv */
2525         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2526                         iv, iv_len);
2527         sym_op->cipher.data.length = cipher_len;
2528         sym_op->cipher.data.offset = cipher_offset;
2529         return 0;
2530 }
2531
2532 static int
2533 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2534                         unsigned int cipher_len,
2535                         unsigned int cipher_offset)
2536 {
2537         struct crypto_testsuite_params *ts_params = &testsuite_params;
2538         struct crypto_unittest_params *ut_params = &unittest_params;
2539
2540         /* Generate Crypto op data structure */
2541         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2542                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2543         TEST_ASSERT_NOT_NULL(ut_params->op,
2544                                 "Failed to allocate pktmbuf offload");
2545
2546         /* Set crypto operation data parameters */
2547         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2548
2549         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2550
2551         /* set crypto operation source mbuf */
2552         sym_op->m_src = ut_params->ibuf;
2553         sym_op->m_dst = ut_params->obuf;
2554
2555         /* iv */
2556         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2557                         iv, iv_len);
2558         sym_op->cipher.data.length = cipher_len;
2559         sym_op->cipher.data.offset = cipher_offset;
2560         return 0;
2561 }
2562
2563 static int
2564 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2565                 enum rte_crypto_cipher_operation cipher_op,
2566                 enum rte_crypto_auth_operation auth_op,
2567                 enum rte_crypto_auth_algorithm auth_algo,
2568                 enum rte_crypto_cipher_algorithm cipher_algo,
2569                 const uint8_t *key, uint8_t key_len,
2570                 uint8_t auth_iv_len, uint8_t auth_len,
2571                 uint8_t cipher_iv_len)
2572
2573 {
2574         uint8_t cipher_auth_key[key_len];
2575         int status;
2576
2577         struct crypto_testsuite_params *ts_params = &testsuite_params;
2578         struct crypto_unittest_params *ut_params = &unittest_params;
2579
2580         memcpy(cipher_auth_key, key, key_len);
2581
2582         /* Setup Authentication Parameters */
2583         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2584         ut_params->auth_xform.next = NULL;
2585
2586         ut_params->auth_xform.auth.op = auth_op;
2587         ut_params->auth_xform.auth.algo = auth_algo;
2588         ut_params->auth_xform.auth.key.length = key_len;
2589         /* Hash key = cipher key */
2590         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2591         ut_params->auth_xform.auth.digest_length = auth_len;
2592         /* Auth IV will be after cipher IV */
2593         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2594         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2595
2596         /* Setup Cipher Parameters */
2597         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2598         ut_params->cipher_xform.next = &ut_params->auth_xform;
2599
2600         ut_params->cipher_xform.cipher.algo = cipher_algo;
2601         ut_params->cipher_xform.cipher.op = cipher_op;
2602         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2603         ut_params->cipher_xform.cipher.key.length = key_len;
2604         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2605         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2606
2607         debug_hexdump(stdout, "key:", key, key_len);
2608
2609         /* Create Crypto session*/
2610         ut_params->sess = rte_cryptodev_sym_session_create(
2611                         ts_params->session_mpool);
2612         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2613
2614         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2615                         &ut_params->cipher_xform,
2616                         ts_params->session_priv_mpool);
2617         if (status == -ENOTSUP)
2618                 return TEST_SKIPPED;
2619
2620         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2621         return 0;
2622 }
2623
2624 static int
2625 create_wireless_cipher_auth_session(uint8_t dev_id,
2626                 enum rte_crypto_cipher_operation cipher_op,
2627                 enum rte_crypto_auth_operation auth_op,
2628                 enum rte_crypto_auth_algorithm auth_algo,
2629                 enum rte_crypto_cipher_algorithm cipher_algo,
2630                 const struct wireless_test_data *tdata)
2631 {
2632         const uint8_t key_len = tdata->key.len;
2633         uint8_t cipher_auth_key[key_len];
2634         int status;
2635
2636         struct crypto_testsuite_params *ts_params = &testsuite_params;
2637         struct crypto_unittest_params *ut_params = &unittest_params;
2638         const uint8_t *key = tdata->key.data;
2639         const uint8_t auth_len = tdata->digest.len;
2640         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2641         uint8_t auth_iv_len = tdata->auth_iv.len;
2642
2643         memcpy(cipher_auth_key, key, key_len);
2644
2645         /* Setup Authentication Parameters */
2646         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2647         ut_params->auth_xform.next = NULL;
2648
2649         ut_params->auth_xform.auth.op = auth_op;
2650         ut_params->auth_xform.auth.algo = auth_algo;
2651         ut_params->auth_xform.auth.key.length = key_len;
2652         /* Hash key = cipher key */
2653         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2654         ut_params->auth_xform.auth.digest_length = auth_len;
2655         /* Auth IV will be after cipher IV */
2656         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2657         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2658
2659         /* Setup Cipher Parameters */
2660         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2661         ut_params->cipher_xform.next = &ut_params->auth_xform;
2662
2663         ut_params->cipher_xform.cipher.algo = cipher_algo;
2664         ut_params->cipher_xform.cipher.op = cipher_op;
2665         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2666         ut_params->cipher_xform.cipher.key.length = key_len;
2667         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2668         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2669
2670
2671         debug_hexdump(stdout, "key:", key, key_len);
2672
2673         /* Create Crypto session*/
2674         ut_params->sess = rte_cryptodev_sym_session_create(
2675                         ts_params->session_mpool);
2676
2677         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2678                         &ut_params->cipher_xform,
2679                         ts_params->session_priv_mpool);
2680         if (status == -ENOTSUP)
2681                 return TEST_SKIPPED;
2682
2683         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2684         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2685         return 0;
2686 }
2687
2688 static int
2689 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2690                 const struct wireless_test_data *tdata)
2691 {
2692         return create_wireless_cipher_auth_session(dev_id,
2693                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2694                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2695                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2696 }
2697
2698 static int
2699 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2700                 enum rte_crypto_cipher_operation cipher_op,
2701                 enum rte_crypto_auth_operation auth_op,
2702                 enum rte_crypto_auth_algorithm auth_algo,
2703                 enum rte_crypto_cipher_algorithm cipher_algo,
2704                 const uint8_t *key, const uint8_t key_len,
2705                 uint8_t auth_iv_len, uint8_t auth_len,
2706                 uint8_t cipher_iv_len)
2707 {
2708         uint8_t auth_cipher_key[key_len];
2709         int status;
2710         struct crypto_testsuite_params *ts_params = &testsuite_params;
2711         struct crypto_unittest_params *ut_params = &unittest_params;
2712
2713         memcpy(auth_cipher_key, key, key_len);
2714
2715         /* Setup Authentication Parameters */
2716         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2717         ut_params->auth_xform.auth.op = auth_op;
2718         ut_params->auth_xform.next = &ut_params->cipher_xform;
2719         ut_params->auth_xform.auth.algo = auth_algo;
2720         ut_params->auth_xform.auth.key.length = key_len;
2721         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2722         ut_params->auth_xform.auth.digest_length = auth_len;
2723         /* Auth IV will be after cipher IV */
2724         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2725         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2726
2727         /* Setup Cipher Parameters */
2728         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2729         ut_params->cipher_xform.next = NULL;
2730         ut_params->cipher_xform.cipher.algo = cipher_algo;
2731         ut_params->cipher_xform.cipher.op = cipher_op;
2732         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2733         ut_params->cipher_xform.cipher.key.length = key_len;
2734         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2735         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2736
2737         debug_hexdump(stdout, "key:", key, key_len);
2738
2739         /* Create Crypto session*/
2740         ut_params->sess = rte_cryptodev_sym_session_create(
2741                         ts_params->session_mpool);
2742         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2743
2744         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2745                 ut_params->auth_xform.next = NULL;
2746                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2747                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2748                                 &ut_params->cipher_xform,
2749                                 ts_params->session_priv_mpool);
2750
2751         } else
2752                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2753                                 &ut_params->auth_xform,
2754                                 ts_params->session_priv_mpool);
2755
2756         if (status == -ENOTSUP)
2757                 return TEST_SKIPPED;
2758
2759         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2760
2761         return 0;
2762 }
2763
2764 static int
2765 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2766                 unsigned int auth_tag_len,
2767                 const uint8_t *iv, unsigned int iv_len,
2768                 unsigned int data_pad_len,
2769                 enum rte_crypto_auth_operation op,
2770                 unsigned int auth_len, unsigned int auth_offset)
2771 {
2772         struct crypto_testsuite_params *ts_params = &testsuite_params;
2773
2774         struct crypto_unittest_params *ut_params = &unittest_params;
2775
2776         /* Generate Crypto op data structure */
2777         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2778                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2779         TEST_ASSERT_NOT_NULL(ut_params->op,
2780                 "Failed to allocate pktmbuf offload");
2781
2782         /* Set crypto operation data parameters */
2783         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2784
2785         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2786
2787         /* set crypto operation source mbuf */
2788         sym_op->m_src = ut_params->ibuf;
2789
2790         /* iv */
2791         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2792                         iv, iv_len);
2793         /* digest */
2794         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2795                                         ut_params->ibuf, auth_tag_len);
2796
2797         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2798                                 "no room to append auth tag");
2799         ut_params->digest = sym_op->auth.digest.data;
2800         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2801                         ut_params->ibuf, data_pad_len);
2802         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2803                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2804         else
2805                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2806
2807         debug_hexdump(stdout, "digest:",
2808                 sym_op->auth.digest.data,
2809                 auth_tag_len);
2810
2811         sym_op->auth.data.length = auth_len;
2812         sym_op->auth.data.offset = auth_offset;
2813
2814         return 0;
2815 }
2816
2817 static int
2818 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2819         enum rte_crypto_auth_operation op)
2820 {
2821         struct crypto_testsuite_params *ts_params = &testsuite_params;
2822         struct crypto_unittest_params *ut_params = &unittest_params;
2823
2824         const uint8_t *auth_tag = tdata->digest.data;
2825         const unsigned int auth_tag_len = tdata->digest.len;
2826         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2827         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2828
2829         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2830         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2831         const uint8_t *auth_iv = tdata->auth_iv.data;
2832         const uint8_t auth_iv_len = tdata->auth_iv.len;
2833         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2834         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2835
2836         /* Generate Crypto op data structure */
2837         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2838                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2839         TEST_ASSERT_NOT_NULL(ut_params->op,
2840                         "Failed to allocate pktmbuf offload");
2841         /* Set crypto operation data parameters */
2842         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2843
2844         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2845
2846         /* set crypto operation source mbuf */
2847         sym_op->m_src = ut_params->ibuf;
2848
2849         /* digest */
2850         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2851                         ut_params->ibuf, auth_tag_len);
2852
2853         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2854                         "no room to append auth tag");
2855         ut_params->digest = sym_op->auth.digest.data;
2856         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2857                         ut_params->ibuf, data_pad_len);
2858         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2859                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2860         else
2861                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2862
2863         debug_hexdump(stdout, "digest:",
2864                 sym_op->auth.digest.data,
2865                 auth_tag_len);
2866
2867         /* Copy cipher and auth IVs at the end of the crypto operation */
2868         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2869                                                 IV_OFFSET);
2870         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2871         iv_ptr += cipher_iv_len;
2872         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2873
2874         sym_op->cipher.data.length = cipher_len;
2875         sym_op->cipher.data.offset = 0;
2876         sym_op->auth.data.length = auth_len;
2877         sym_op->auth.data.offset = 0;
2878
2879         return 0;
2880 }
2881
2882 static int
2883 create_zuc_cipher_hash_generate_operation(
2884                 const struct wireless_test_data *tdata)
2885 {
2886         return create_wireless_cipher_hash_operation(tdata,
2887                 RTE_CRYPTO_AUTH_OP_GENERATE);
2888 }
2889
2890 static int
2891 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2892                 const unsigned auth_tag_len,
2893                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2894                 unsigned data_pad_len,
2895                 enum rte_crypto_auth_operation op,
2896                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2897                 const unsigned cipher_len, const unsigned cipher_offset,
2898                 const unsigned auth_len, const unsigned auth_offset)
2899 {
2900         struct crypto_testsuite_params *ts_params = &testsuite_params;
2901         struct crypto_unittest_params *ut_params = &unittest_params;
2902
2903         enum rte_crypto_cipher_algorithm cipher_algo =
2904                         ut_params->cipher_xform.cipher.algo;
2905         enum rte_crypto_auth_algorithm auth_algo =
2906                         ut_params->auth_xform.auth.algo;
2907
2908         /* Generate Crypto op data structure */
2909         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2910                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2911         TEST_ASSERT_NOT_NULL(ut_params->op,
2912                         "Failed to allocate pktmbuf offload");
2913         /* Set crypto operation data parameters */
2914         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2915
2916         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2917
2918         /* set crypto operation source mbuf */
2919         sym_op->m_src = ut_params->ibuf;
2920
2921         /* digest */
2922         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2923                         ut_params->ibuf, auth_tag_len);
2924
2925         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2926                         "no room to append auth tag");
2927         ut_params->digest = sym_op->auth.digest.data;
2928
2929         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2930                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2931                                 ut_params->ibuf, data_pad_len);
2932         } else {
2933                 struct rte_mbuf *m = ut_params->ibuf;
2934                 unsigned int offset = data_pad_len;
2935
2936                 while (offset > m->data_len && m->next != NULL) {
2937                         offset -= m->data_len;
2938                         m = m->next;
2939                 }
2940                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2941                         m, offset);
2942         }
2943
2944         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2945                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2946         else
2947                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2948
2949         debug_hexdump(stdout, "digest:",
2950                 sym_op->auth.digest.data,
2951                 auth_tag_len);
2952
2953         /* Copy cipher and auth IVs at the end of the crypto operation */
2954         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2955                                                 IV_OFFSET);
2956         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2957         iv_ptr += cipher_iv_len;
2958         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2959
2960         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2961                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2962                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2963                 sym_op->cipher.data.length = cipher_len;
2964                 sym_op->cipher.data.offset = cipher_offset;
2965         } else {
2966                 sym_op->cipher.data.length = cipher_len >> 3;
2967                 sym_op->cipher.data.offset = cipher_offset >> 3;
2968         }
2969
2970         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2971                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2972                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2973                 sym_op->auth.data.length = auth_len;
2974                 sym_op->auth.data.offset = auth_offset;
2975         } else {
2976                 sym_op->auth.data.length = auth_len >> 3;
2977                 sym_op->auth.data.offset = auth_offset >> 3;
2978         }
2979
2980         return 0;
2981 }
2982
2983 static int
2984 create_wireless_algo_auth_cipher_operation(
2985                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2986                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2987                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2988                 unsigned int data_pad_len,
2989                 unsigned int cipher_len, unsigned int cipher_offset,
2990                 unsigned int auth_len, unsigned int auth_offset,
2991                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
2992 {
2993         struct crypto_testsuite_params *ts_params = &testsuite_params;
2994         struct crypto_unittest_params *ut_params = &unittest_params;
2995
2996         enum rte_crypto_cipher_algorithm cipher_algo =
2997                         ut_params->cipher_xform.cipher.algo;
2998         enum rte_crypto_auth_algorithm auth_algo =
2999                         ut_params->auth_xform.auth.algo;
3000
3001         /* Generate Crypto op data structure */
3002         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3003                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3004         TEST_ASSERT_NOT_NULL(ut_params->op,
3005                         "Failed to allocate pktmbuf offload");
3006
3007         /* Set crypto operation data parameters */
3008         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3009
3010         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3011
3012         /* set crypto operation mbufs */
3013         sym_op->m_src = ut_params->ibuf;
3014         if (op_mode == OUT_OF_PLACE)
3015                 sym_op->m_dst = ut_params->obuf;
3016
3017         /* digest */
3018         if (!do_sgl) {
3019                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3020                         (op_mode == IN_PLACE ?
3021                                 ut_params->ibuf : ut_params->obuf),
3022                         uint8_t *, data_pad_len);
3023                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3024                         (op_mode == IN_PLACE ?
3025                                 ut_params->ibuf : ut_params->obuf),
3026                         data_pad_len);
3027                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3028         } else {
3029                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3030                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3031                                 sym_op->m_src : sym_op->m_dst);
3032                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3033                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3034                         sgl_buf = sgl_buf->next;
3035                 }
3036                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3037                                 uint8_t *, remaining_off);
3038                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3039                                 remaining_off);
3040                 memset(sym_op->auth.digest.data, 0, remaining_off);
3041                 while (sgl_buf->next != NULL) {
3042                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3043                                 0, rte_pktmbuf_data_len(sgl_buf));
3044                         sgl_buf = sgl_buf->next;
3045                 }
3046         }
3047
3048         /* Copy digest for the verification */
3049         if (verify)
3050                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3051
3052         /* Copy cipher and auth IVs at the end of the crypto operation */
3053         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3054                         ut_params->op, uint8_t *, IV_OFFSET);
3055
3056         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3057         iv_ptr += cipher_iv_len;
3058         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3059
3060         /* Only copy over the offset data needed from src to dst in OOP,
3061          * if the auth and cipher offsets are not aligned
3062          */
3063         if (op_mode == OUT_OF_PLACE) {
3064                 if (cipher_offset > auth_offset)
3065                         rte_memcpy(
3066                                 rte_pktmbuf_mtod_offset(
3067                                         sym_op->m_dst,
3068                                         uint8_t *, auth_offset >> 3),
3069                                 rte_pktmbuf_mtod_offset(
3070                                         sym_op->m_src,
3071                                         uint8_t *, auth_offset >> 3),
3072                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3073         }
3074
3075         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3076                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3077                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3078                 sym_op->cipher.data.length = cipher_len;
3079                 sym_op->cipher.data.offset = cipher_offset;
3080         } else {
3081                 sym_op->cipher.data.length = cipher_len >> 3;
3082                 sym_op->cipher.data.offset = cipher_offset >> 3;
3083         }
3084
3085         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3086                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3087                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3088                 sym_op->auth.data.length = auth_len;
3089                 sym_op->auth.data.offset = auth_offset;
3090         } else {
3091                 sym_op->auth.data.length = auth_len >> 3;
3092                 sym_op->auth.data.offset = auth_offset >> 3;
3093         }
3094
3095         return 0;
3096 }
3097
3098 static int
3099 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3100 {
3101         struct crypto_testsuite_params *ts_params = &testsuite_params;
3102         struct crypto_unittest_params *ut_params = &unittest_params;
3103
3104         int retval;
3105         unsigned plaintext_pad_len;
3106         unsigned plaintext_len;
3107         uint8_t *plaintext;
3108         struct rte_cryptodev_info dev_info;
3109
3110         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3111         uint64_t feat_flags = dev_info.feature_flags;
3112
3113         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3114                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3115                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3116                 return TEST_SKIPPED;
3117         }
3118
3119         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3120                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3121                 printf("Device doesn't support RAW data-path APIs.\n");
3122                 return TEST_SKIPPED;
3123         }
3124
3125         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3126                 return TEST_SKIPPED;
3127
3128         /* Verify the capabilities */
3129         struct rte_cryptodev_sym_capability_idx cap_idx;
3130         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3131         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3132         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3133                         &cap_idx) == NULL)
3134                 return TEST_SKIPPED;
3135
3136         /* Create SNOW 3G session */
3137         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3138                         tdata->key.data, tdata->key.len,
3139                         tdata->auth_iv.len, tdata->digest.len,
3140                         RTE_CRYPTO_AUTH_OP_GENERATE,
3141                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3142         if (retval < 0)
3143                 return retval;
3144
3145         /* alloc mbuf and set payload */
3146         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3147
3148         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3149         rte_pktmbuf_tailroom(ut_params->ibuf));
3150
3151         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3152         /* Append data which is padded to a multiple of */
3153         /* the algorithms block size */
3154         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3155         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3156                                 plaintext_pad_len);
3157         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3158
3159         /* Create SNOW 3G operation */
3160         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3161                         tdata->auth_iv.data, tdata->auth_iv.len,
3162                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3163                         tdata->validAuthLenInBits.len,
3164                         0);
3165         if (retval < 0)
3166                 return retval;
3167
3168         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3169                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3170                                 ut_params->op, 0, 1, 1, 0);
3171         else
3172                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3173                                 ut_params->op);
3174         ut_params->obuf = ut_params->op->sym->m_src;
3175         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3176         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3177                         + plaintext_pad_len;
3178
3179         /* Validate obuf */
3180         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3181         ut_params->digest,
3182         tdata->digest.data,
3183         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3184         "SNOW 3G Generated auth tag not as expected");
3185
3186         return 0;
3187 }
3188
3189 static int
3190 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3191 {
3192         struct crypto_testsuite_params *ts_params = &testsuite_params;
3193         struct crypto_unittest_params *ut_params = &unittest_params;
3194
3195         int retval;
3196         unsigned plaintext_pad_len;
3197         unsigned plaintext_len;
3198         uint8_t *plaintext;
3199         struct rte_cryptodev_info dev_info;
3200
3201         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3202         uint64_t feat_flags = dev_info.feature_flags;
3203
3204         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3205                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3206                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3207                 return TEST_SKIPPED;
3208         }
3209
3210         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3211                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3212                 printf("Device doesn't support RAW data-path APIs.\n");
3213                 return TEST_SKIPPED;
3214         }
3215
3216         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3217                 return TEST_SKIPPED;
3218
3219         /* Verify the capabilities */
3220         struct rte_cryptodev_sym_capability_idx cap_idx;
3221         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3222         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3223         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3224                         &cap_idx) == NULL)
3225                 return TEST_SKIPPED;
3226
3227         /* Create SNOW 3G session */
3228         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3229                                 tdata->key.data, tdata->key.len,
3230                                 tdata->auth_iv.len, tdata->digest.len,
3231                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3232                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3233         if (retval < 0)
3234                 return retval;
3235         /* alloc mbuf and set payload */
3236         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3237
3238         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3239         rte_pktmbuf_tailroom(ut_params->ibuf));
3240
3241         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3242         /* Append data which is padded to a multiple of */
3243         /* the algorithms block size */
3244         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3245         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3246                                 plaintext_pad_len);
3247         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3248
3249         /* Create SNOW 3G operation */
3250         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3251                         tdata->digest.len,
3252                         tdata->auth_iv.data, tdata->auth_iv.len,
3253                         plaintext_pad_len,
3254                         RTE_CRYPTO_AUTH_OP_VERIFY,
3255                         tdata->validAuthLenInBits.len,
3256                         0);
3257         if (retval < 0)
3258                 return retval;
3259
3260         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3261                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3262                                 ut_params->op, 0, 1, 1, 0);
3263         else
3264                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3265                                 ut_params->op);
3266         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3267         ut_params->obuf = ut_params->op->sym->m_src;
3268         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3269                                 + plaintext_pad_len;
3270
3271         /* Validate obuf */
3272         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3273                 return 0;
3274         else
3275                 return -1;
3276
3277         return 0;
3278 }
3279
3280 static int
3281 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3282 {
3283         struct crypto_testsuite_params *ts_params = &testsuite_params;
3284         struct crypto_unittest_params *ut_params = &unittest_params;
3285
3286         int retval;
3287         unsigned plaintext_pad_len;
3288         unsigned plaintext_len;
3289         uint8_t *plaintext;
3290         struct rte_cryptodev_info dev_info;
3291
3292         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3293         uint64_t feat_flags = dev_info.feature_flags;
3294
3295         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3296                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3297                 printf("Device doesn't support RAW data-path APIs.\n");
3298                 return TEST_SKIPPED;
3299         }
3300
3301         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3302                 return TEST_SKIPPED;
3303
3304         /* Verify the capabilities */
3305         struct rte_cryptodev_sym_capability_idx cap_idx;
3306         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3307         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3308         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3309                         &cap_idx) == NULL)
3310                 return TEST_SKIPPED;
3311
3312         /* Create KASUMI session */
3313         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3314                         tdata->key.data, tdata->key.len,
3315                         0, tdata->digest.len,
3316                         RTE_CRYPTO_AUTH_OP_GENERATE,
3317                         RTE_CRYPTO_AUTH_KASUMI_F9);
3318         if (retval < 0)
3319                 return retval;
3320
3321         /* alloc mbuf and set payload */
3322         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3323
3324         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3325         rte_pktmbuf_tailroom(ut_params->ibuf));
3326
3327         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3328         /* Append data which is padded to a multiple of */
3329         /* the algorithms block size */
3330         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3331         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3332                                 plaintext_pad_len);
3333         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3334
3335         /* Create KASUMI operation */
3336         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3337                         NULL, 0,
3338                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3339                         tdata->plaintext.len,
3340                         0);
3341         if (retval < 0)
3342                 return retval;
3343
3344         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3345                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3346                         ut_params->op);
3347         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3348                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3349                                 ut_params->op, 0, 1, 1, 0);
3350         else
3351                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3352                         ut_params->op);
3353
3354         ut_params->obuf = ut_params->op->sym->m_src;
3355         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3356         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3357                         + plaintext_pad_len;
3358
3359         /* Validate obuf */
3360         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3361         ut_params->digest,
3362         tdata->digest.data,
3363         DIGEST_BYTE_LENGTH_KASUMI_F9,
3364         "KASUMI Generated auth tag not as expected");
3365
3366         return 0;
3367 }
3368
3369 static int
3370 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3371 {
3372         struct crypto_testsuite_params *ts_params = &testsuite_params;
3373         struct crypto_unittest_params *ut_params = &unittest_params;
3374
3375         int retval;
3376         unsigned plaintext_pad_len;
3377         unsigned plaintext_len;
3378         uint8_t *plaintext;
3379         struct rte_cryptodev_info dev_info;
3380
3381         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3382         uint64_t feat_flags = dev_info.feature_flags;
3383
3384         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3385                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3386                 printf("Device doesn't support RAW data-path APIs.\n");
3387                 return TEST_SKIPPED;
3388         }
3389
3390         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3391                 return TEST_SKIPPED;
3392
3393         /* Verify the capabilities */
3394         struct rte_cryptodev_sym_capability_idx cap_idx;
3395         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3396         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3397         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3398                         &cap_idx) == NULL)
3399                 return TEST_SKIPPED;
3400
3401         /* Create KASUMI session */
3402         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3403                                 tdata->key.data, tdata->key.len,
3404                                 0, tdata->digest.len,
3405                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3406                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3407         if (retval < 0)
3408                 return retval;
3409         /* alloc mbuf and set payload */
3410         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3411
3412         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3413         rte_pktmbuf_tailroom(ut_params->ibuf));
3414
3415         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3416         /* Append data which is padded to a multiple */
3417         /* of the algorithms block size */
3418         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3419         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3420                                 plaintext_pad_len);
3421         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3422
3423         /* Create KASUMI operation */
3424         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3425                         tdata->digest.len,
3426                         NULL, 0,
3427                         plaintext_pad_len,
3428                         RTE_CRYPTO_AUTH_OP_VERIFY,
3429                         tdata->plaintext.len,
3430                         0);
3431         if (retval < 0)
3432                 return retval;
3433
3434         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3435                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3436                                 ut_params->op, 0, 1, 1, 0);
3437         else
3438                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3439                                 ut_params->op);
3440         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3441         ut_params->obuf = ut_params->op->sym->m_src;
3442         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3443                                 + plaintext_pad_len;
3444
3445         /* Validate obuf */
3446         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3447                 return 0;
3448         else
3449                 return -1;
3450
3451         return 0;
3452 }
3453
3454 static int
3455 test_snow3g_hash_generate_test_case_1(void)
3456 {
3457         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3458 }
3459
3460 static int
3461 test_snow3g_hash_generate_test_case_2(void)
3462 {
3463         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3464 }
3465
3466 static int
3467 test_snow3g_hash_generate_test_case_3(void)
3468 {
3469         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3470 }
3471
3472 static int
3473 test_snow3g_hash_generate_test_case_4(void)
3474 {
3475         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3476 }
3477
3478 static int
3479 test_snow3g_hash_generate_test_case_5(void)
3480 {
3481         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3482 }
3483
3484 static int
3485 test_snow3g_hash_generate_test_case_6(void)
3486 {
3487         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3488 }
3489
3490 static int
3491 test_snow3g_hash_verify_test_case_1(void)
3492 {
3493         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3494
3495 }
3496
3497 static int
3498 test_snow3g_hash_verify_test_case_2(void)
3499 {
3500         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3501 }
3502
3503 static int
3504 test_snow3g_hash_verify_test_case_3(void)
3505 {
3506         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3507 }
3508
3509 static int
3510 test_snow3g_hash_verify_test_case_4(void)
3511 {
3512         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3513 }
3514
3515 static int
3516 test_snow3g_hash_verify_test_case_5(void)
3517 {
3518         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3519 }
3520
3521 static int
3522 test_snow3g_hash_verify_test_case_6(void)
3523 {
3524         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3525 }
3526
3527 static int
3528 test_kasumi_hash_generate_test_case_1(void)
3529 {
3530         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3531 }
3532
3533 static int
3534 test_kasumi_hash_generate_test_case_2(void)
3535 {
3536         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3537 }
3538
3539 static int
3540 test_kasumi_hash_generate_test_case_3(void)
3541 {
3542         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3543 }
3544
3545 static int
3546 test_kasumi_hash_generate_test_case_4(void)
3547 {
3548         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3549 }
3550
3551 static int
3552 test_kasumi_hash_generate_test_case_5(void)
3553 {
3554         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3555 }
3556
3557 static int
3558 test_kasumi_hash_generate_test_case_6(void)
3559 {
3560         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3561 }
3562
3563 static int
3564 test_kasumi_hash_verify_test_case_1(void)
3565 {
3566         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3567 }
3568
3569 static int
3570 test_kasumi_hash_verify_test_case_2(void)
3571 {
3572         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3573 }
3574
3575 static int
3576 test_kasumi_hash_verify_test_case_3(void)
3577 {
3578         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3579 }
3580
3581 static int
3582 test_kasumi_hash_verify_test_case_4(void)
3583 {
3584         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3585 }
3586
3587 static int
3588 test_kasumi_hash_verify_test_case_5(void)
3589 {
3590         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3591 }
3592
3593 static int
3594 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3595 {
3596         struct crypto_testsuite_params *ts_params = &testsuite_params;
3597         struct crypto_unittest_params *ut_params = &unittest_params;
3598
3599         int retval;
3600         uint8_t *plaintext, *ciphertext;
3601         unsigned plaintext_pad_len;
3602         unsigned plaintext_len;
3603         struct rte_cryptodev_info dev_info;
3604
3605         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3606         uint64_t feat_flags = dev_info.feature_flags;
3607
3608         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3609                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3610                 printf("Device doesn't support RAW data-path APIs.\n");
3611                 return TEST_SKIPPED;
3612         }
3613
3614         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3615                 return TEST_SKIPPED;
3616
3617         /* Verify the capabilities */
3618         struct rte_cryptodev_sym_capability_idx cap_idx;
3619         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3620         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3621         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3622                         &cap_idx) == NULL)
3623                 return TEST_SKIPPED;
3624
3625         /* Create KASUMI session */
3626         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3627                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3628                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3629                                         tdata->key.data, tdata->key.len,
3630                                         tdata->cipher_iv.len);
3631         if (retval < 0)
3632                 return retval;
3633
3634         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3635
3636         /* Clear mbuf payload */
3637         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3638                rte_pktmbuf_tailroom(ut_params->ibuf));
3639
3640         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3641         /* Append data which is padded to a multiple */
3642         /* of the algorithms block size */
3643         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3644         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3645                                 plaintext_pad_len);
3646         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3647
3648         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3649
3650         /* Create KASUMI operation */
3651         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3652                                 tdata->cipher_iv.len,
3653                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3654                                 tdata->validCipherOffsetInBits.len);
3655         if (retval < 0)
3656                 return retval;
3657
3658         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3659                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3660                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3661         else
3662                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3663                                 ut_params->op);
3664         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3665
3666         ut_params->obuf = ut_params->op->sym->m_dst;
3667         if (ut_params->obuf)
3668                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3669         else
3670                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3671
3672         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3673
3674         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3675                                 (tdata->validCipherOffsetInBits.len >> 3);
3676         /* Validate obuf */
3677         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3678                 ciphertext,
3679                 reference_ciphertext,
3680                 tdata->validCipherLenInBits.len,
3681                 "KASUMI Ciphertext data not as expected");
3682         return 0;
3683 }
3684
3685 static int
3686 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3687 {
3688         struct crypto_testsuite_params *ts_params = &testsuite_params;
3689         struct crypto_unittest_params *ut_params = &unittest_params;
3690
3691         int retval;
3692
3693         unsigned int plaintext_pad_len;
3694         unsigned int plaintext_len;
3695
3696         uint8_t buffer[10000];
3697         const uint8_t *ciphertext;
3698
3699         struct rte_cryptodev_info dev_info;
3700
3701         /* Verify the capabilities */
3702         struct rte_cryptodev_sym_capability_idx cap_idx;
3703         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3704         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3705         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3706                         &cap_idx) == NULL)
3707                 return TEST_SKIPPED;
3708
3709         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3710
3711         uint64_t feat_flags = dev_info.feature_flags;
3712
3713         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3714                 printf("Device doesn't support in-place scatter-gather. "
3715                                 "Test Skipped.\n");
3716                 return TEST_SKIPPED;
3717         }
3718
3719         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3720                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3721                 printf("Device doesn't support RAW data-path APIs.\n");
3722                 return TEST_SKIPPED;
3723         }
3724
3725         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3726                 return TEST_SKIPPED;
3727
3728         /* Create KASUMI session */
3729         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3730                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3731                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3732                                         tdata->key.data, tdata->key.len,
3733                                         tdata->cipher_iv.len);
3734         if (retval < 0)
3735                 return retval;
3736
3737         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3738
3739
3740         /* Append data which is padded to a multiple */
3741         /* of the algorithms block size */
3742         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3743
3744         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3745                         plaintext_pad_len, 10, 0);
3746
3747         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3748
3749         /* Create KASUMI operation */
3750         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3751                                 tdata->cipher_iv.len,
3752                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3753                                 tdata->validCipherOffsetInBits.len);
3754         if (retval < 0)
3755                 return retval;
3756
3757         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3758                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3759                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3760         else
3761                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3762                                                 ut_params->op);
3763         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3764
3765         ut_params->obuf = ut_params->op->sym->m_dst;
3766
3767         if (ut_params->obuf)
3768                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3769                                 plaintext_len, buffer);
3770         else
3771                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3772                                 tdata->validCipherOffsetInBits.len >> 3,
3773                                 plaintext_len, buffer);
3774
3775         /* Validate obuf */
3776         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3777
3778         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3779                                 (tdata->validCipherOffsetInBits.len >> 3);
3780         /* Validate obuf */
3781         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3782                 ciphertext,
3783                 reference_ciphertext,
3784                 tdata->validCipherLenInBits.len,
3785                 "KASUMI Ciphertext data not as expected");
3786         return 0;
3787 }
3788
3789 static int
3790 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3791 {
3792         struct crypto_testsuite_params *ts_params = &testsuite_params;
3793         struct crypto_unittest_params *ut_params = &unittest_params;
3794
3795         int retval;
3796         uint8_t *plaintext, *ciphertext;
3797         unsigned plaintext_pad_len;
3798         unsigned plaintext_len;
3799
3800         /* Verify the capabilities */
3801         struct rte_cryptodev_sym_capability_idx cap_idx;
3802         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3803         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3804         /* Data-path service does not support OOP */
3805         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3806                         &cap_idx) == NULL)
3807                 return TEST_SKIPPED;
3808
3809         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3810                 return TEST_SKIPPED;
3811
3812         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3813                 return TEST_SKIPPED;
3814
3815         /* Create KASUMI session */
3816         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3817                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3818                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3819                                         tdata->key.data, tdata->key.len,
3820                                         tdata->cipher_iv.len);
3821         if (retval < 0)
3822                 return retval;
3823
3824         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3825         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3826
3827         /* Clear mbuf payload */
3828         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3829                rte_pktmbuf_tailroom(ut_params->ibuf));
3830
3831         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3832         /* Append data which is padded to a multiple */
3833         /* of the algorithms block size */
3834         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3835         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3836                                 plaintext_pad_len);
3837         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3838         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3839
3840         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3841
3842         /* Create KASUMI operation */
3843         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3844                                 tdata->cipher_iv.len,
3845                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3846                                 tdata->validCipherOffsetInBits.len);
3847         if (retval < 0)
3848                 return retval;
3849
3850         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3851                                                 ut_params->op);
3852         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3853
3854         ut_params->obuf = ut_params->op->sym->m_dst;
3855         if (ut_params->obuf)
3856                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3857         else
3858                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3859
3860         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3861
3862         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3863                                 (tdata->validCipherOffsetInBits.len >> 3);
3864         /* Validate obuf */
3865         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3866                 ciphertext,
3867                 reference_ciphertext,
3868                 tdata->validCipherLenInBits.len,
3869                 "KASUMI Ciphertext data not as expected");
3870         return 0;
3871 }
3872
3873 static int
3874 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3875 {
3876         struct crypto_testsuite_params *ts_params = &testsuite_params;
3877         struct crypto_unittest_params *ut_params = &unittest_params;
3878
3879         int retval;
3880         unsigned int plaintext_pad_len;
3881         unsigned int plaintext_len;
3882
3883         const uint8_t *ciphertext;
3884         uint8_t buffer[2048];
3885
3886         struct rte_cryptodev_info dev_info;
3887
3888         /* Verify the capabilities */
3889         struct rte_cryptodev_sym_capability_idx cap_idx;
3890         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3891         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3892         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3893                         &cap_idx) == NULL)
3894                 return TEST_SKIPPED;
3895
3896         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3897                 return TEST_SKIPPED;
3898
3899         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3900                 return TEST_SKIPPED;
3901
3902         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3903
3904         uint64_t feat_flags = dev_info.feature_flags;
3905         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3906                 printf("Device doesn't support out-of-place scatter-gather "
3907                                 "in both input and output mbufs. "
3908                                 "Test Skipped.\n");
3909                 return TEST_SKIPPED;
3910         }
3911
3912         /* Create KASUMI session */
3913         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3914                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3915                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3916                                         tdata->key.data, tdata->key.len,
3917                                         tdata->cipher_iv.len);
3918         if (retval < 0)
3919                 return retval;
3920
3921         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3922         /* Append data which is padded to a multiple */
3923         /* of the algorithms block size */
3924         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3925
3926         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3927                         plaintext_pad_len, 10, 0);
3928         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3929                         plaintext_pad_len, 3, 0);
3930
3931         /* Append data which is padded to a multiple */
3932         /* of the algorithms block size */
3933         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3934
3935         /* Create KASUMI operation */
3936         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3937                                 tdata->cipher_iv.len,
3938                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3939                                 tdata->validCipherOffsetInBits.len);
3940         if (retval < 0)
3941                 return retval;
3942
3943         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3944                                                 ut_params->op);
3945         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3946
3947         ut_params->obuf = ut_params->op->sym->m_dst;
3948         if (ut_params->obuf)
3949                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3950                                 plaintext_pad_len, buffer);
3951         else
3952                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3953                                 tdata->validCipherOffsetInBits.len >> 3,
3954                                 plaintext_pad_len, buffer);
3955
3956         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3957                                 (tdata->validCipherOffsetInBits.len >> 3);
3958         /* Validate obuf */
3959         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3960                 ciphertext,
3961                 reference_ciphertext,
3962                 tdata->validCipherLenInBits.len,
3963                 "KASUMI Ciphertext data not as expected");
3964         return 0;
3965 }
3966
3967
3968 static int
3969 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3970 {
3971         struct crypto_testsuite_params *ts_params = &testsuite_params;
3972         struct crypto_unittest_params *ut_params = &unittest_params;
3973
3974         int retval;
3975         uint8_t *ciphertext, *plaintext;
3976         unsigned ciphertext_pad_len;
3977         unsigned ciphertext_len;
3978
3979         /* Verify the capabilities */
3980         struct rte_cryptodev_sym_capability_idx cap_idx;
3981         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3982         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3983         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3984                         &cap_idx) == NULL)
3985                 return TEST_SKIPPED;
3986
3987         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3988                 return TEST_SKIPPED;
3989
3990         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3991                 return TEST_SKIPPED;
3992
3993         /* Create KASUMI session */
3994         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3995                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
3996                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3997                                         tdata->key.data, tdata->key.len,
3998                                         tdata->cipher_iv.len);
3999         if (retval < 0)
4000                 return retval;
4001
4002         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4003         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4004
4005         /* Clear mbuf payload */
4006         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4007                rte_pktmbuf_tailroom(ut_params->ibuf));
4008
4009         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4010         /* Append data which is padded to a multiple */
4011         /* of the algorithms block size */
4012         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4013         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4014                                 ciphertext_pad_len);
4015         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4016         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4017
4018         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4019
4020         /* Create KASUMI operation */
4021         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4022                                 tdata->cipher_iv.len,
4023                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4024                                 tdata->validCipherOffsetInBits.len);
4025         if (retval < 0)
4026                 return retval;
4027
4028         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4029                                                 ut_params->op);
4030         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4031
4032         ut_params->obuf = ut_params->op->sym->m_dst;
4033         if (ut_params->obuf)
4034                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4035         else
4036                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4037
4038         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4039
4040         const uint8_t *reference_plaintext = tdata->plaintext.data +
4041                                 (tdata->validCipherOffsetInBits.len >> 3);
4042         /* Validate obuf */
4043         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4044                 plaintext,
4045                 reference_plaintext,
4046                 tdata->validCipherLenInBits.len,
4047                 "KASUMI Plaintext data not as expected");
4048         return 0;
4049 }
4050
4051 static int
4052 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4053 {
4054         struct crypto_testsuite_params *ts_params = &testsuite_params;
4055         struct crypto_unittest_params *ut_params = &unittest_params;
4056
4057         int retval;
4058         uint8_t *ciphertext, *plaintext;
4059         unsigned ciphertext_pad_len;
4060         unsigned ciphertext_len;
4061         struct rte_cryptodev_info dev_info;
4062
4063         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4064         uint64_t feat_flags = dev_info.feature_flags;
4065
4066         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4067                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4068                 printf("Device doesn't support RAW data-path APIs.\n");
4069                 return TEST_SKIPPED;
4070         }
4071
4072         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4073                 return TEST_SKIPPED;
4074
4075         /* Verify the capabilities */
4076         struct rte_cryptodev_sym_capability_idx cap_idx;
4077         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4078         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4079         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4080                         &cap_idx) == NULL)
4081                 return TEST_SKIPPED;
4082
4083         /* Create KASUMI session */
4084         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4085                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4086                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4087                                         tdata->key.data, tdata->key.len,
4088                                         tdata->cipher_iv.len);
4089         if (retval < 0)
4090                 return retval;
4091
4092         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4093
4094         /* Clear mbuf payload */
4095         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4096                rte_pktmbuf_tailroom(ut_params->ibuf));
4097
4098         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4099         /* Append data which is padded to a multiple */
4100         /* of the algorithms block size */
4101         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4102         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4103                                 ciphertext_pad_len);
4104         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4105
4106         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4107
4108         /* Create KASUMI operation */
4109         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4110                         tdata->cipher_iv.len,
4111                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4112                         tdata->validCipherOffsetInBits.len);
4113         if (retval < 0)
4114                 return retval;
4115
4116         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4117                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4118                                 ut_params->op, 1, 0, 1, 0);
4119         else
4120                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4121                                                 ut_params->op);
4122         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4123
4124         ut_params->obuf = ut_params->op->sym->m_dst;
4125         if (ut_params->obuf)
4126                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4127         else
4128                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4129
4130         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4131
4132         const uint8_t *reference_plaintext = tdata->plaintext.data +
4133                                 (tdata->validCipherOffsetInBits.len >> 3);
4134         /* Validate obuf */
4135         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4136                 plaintext,
4137                 reference_plaintext,
4138                 tdata->validCipherLenInBits.len,
4139                 "KASUMI Plaintext data not as expected");
4140         return 0;
4141 }
4142
4143 static int
4144 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4145 {
4146         struct crypto_testsuite_params *ts_params = &testsuite_params;
4147         struct crypto_unittest_params *ut_params = &unittest_params;
4148
4149         int retval;
4150         uint8_t *plaintext, *ciphertext;
4151         unsigned plaintext_pad_len;
4152         unsigned plaintext_len;
4153         struct rte_cryptodev_info dev_info;
4154
4155         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4156         uint64_t feat_flags = dev_info.feature_flags;
4157
4158         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4159                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4160                 printf("Device doesn't support RAW data-path APIs.\n");
4161                 return TEST_SKIPPED;
4162         }
4163
4164         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4165                 return TEST_SKIPPED;
4166
4167         /* Verify the capabilities */
4168         struct rte_cryptodev_sym_capability_idx cap_idx;
4169         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4170         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4171         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4172                         &cap_idx) == NULL)
4173                 return TEST_SKIPPED;
4174
4175         /* Create SNOW 3G session */
4176         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4177                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4178                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4179                                         tdata->key.data, tdata->key.len,
4180                                         tdata->cipher_iv.len);
4181         if (retval < 0)
4182                 return retval;
4183
4184         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4185
4186         /* Clear mbuf payload */
4187         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4188                rte_pktmbuf_tailroom(ut_params->ibuf));
4189
4190         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4191         /* Append data which is padded to a multiple of */
4192         /* the algorithms block size */
4193         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4194         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4195                                 plaintext_pad_len);
4196         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4197
4198         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4199
4200         /* Create SNOW 3G operation */
4201         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4202                                         tdata->cipher_iv.len,
4203                                         tdata->validCipherLenInBits.len,
4204                                         0);
4205         if (retval < 0)
4206                 return retval;
4207
4208         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4209                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4210                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4211         else
4212                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4213                                                 ut_params->op);
4214         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4215
4216         ut_params->obuf = ut_params->op->sym->m_dst;
4217         if (ut_params->obuf)
4218                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4219         else
4220                 ciphertext = plaintext;
4221
4222         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4223
4224         /* Validate obuf */
4225         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4226                 ciphertext,
4227                 tdata->ciphertext.data,
4228                 tdata->validDataLenInBits.len,
4229                 "SNOW 3G Ciphertext data not as expected");
4230         return 0;
4231 }
4232
4233
4234 static int
4235 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4236 {
4237         struct crypto_testsuite_params *ts_params = &testsuite_params;
4238         struct crypto_unittest_params *ut_params = &unittest_params;
4239         uint8_t *plaintext, *ciphertext;
4240
4241         int retval;
4242         unsigned plaintext_pad_len;
4243         unsigned plaintext_len;
4244         struct rte_cryptodev_info dev_info;
4245
4246         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4247         uint64_t feat_flags = dev_info.feature_flags;
4248
4249         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4250                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4251                 printf("Device does not support RAW data-path APIs.\n");
4252                 return -ENOTSUP;
4253         }
4254
4255         /* Verify the capabilities */
4256         struct rte_cryptodev_sym_capability_idx cap_idx;
4257         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4258         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4259         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4260                         &cap_idx) == NULL)
4261                 return TEST_SKIPPED;
4262
4263         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4264                 return TEST_SKIPPED;
4265
4266         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4267                 return TEST_SKIPPED;
4268
4269         /* Create SNOW 3G session */
4270         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4271                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4272                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4273                                         tdata->key.data, tdata->key.len,
4274                                         tdata->cipher_iv.len);
4275         if (retval < 0)
4276                 return retval;
4277
4278         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4279         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4280
4281         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4282                         "Failed to allocate input buffer in mempool");
4283         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4284                         "Failed to allocate output buffer in mempool");
4285
4286         /* Clear mbuf payload */
4287         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4288                rte_pktmbuf_tailroom(ut_params->ibuf));
4289
4290         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4291         /* Append data which is padded to a multiple of */
4292         /* the algorithms block size */
4293         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4294         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4295                                 plaintext_pad_len);
4296         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4297         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4298
4299         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4300
4301         /* Create SNOW 3G operation */
4302         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4303                                         tdata->cipher_iv.len,
4304                                         tdata->validCipherLenInBits.len,
4305                                         0);
4306         if (retval < 0)
4307                 return retval;
4308
4309         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4310                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4311                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4312         else
4313                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4314                                                 ut_params->op);
4315         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4316
4317         ut_params->obuf = ut_params->op->sym->m_dst;
4318         if (ut_params->obuf)
4319                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4320         else
4321                 ciphertext = plaintext;
4322
4323         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4324
4325         /* Validate obuf */
4326         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4327                 ciphertext,
4328                 tdata->ciphertext.data,
4329                 tdata->validDataLenInBits.len,
4330                 "SNOW 3G Ciphertext data not as expected");
4331         return 0;
4332 }
4333
4334 static int
4335 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4336 {
4337         struct crypto_testsuite_params *ts_params = &testsuite_params;
4338         struct crypto_unittest_params *ut_params = &unittest_params;
4339
4340         int retval;
4341         unsigned int plaintext_pad_len;
4342         unsigned int plaintext_len;
4343         uint8_t buffer[10000];
4344         const uint8_t *ciphertext;
4345
4346         struct rte_cryptodev_info dev_info;
4347
4348         /* Verify the capabilities */
4349         struct rte_cryptodev_sym_capability_idx cap_idx;
4350         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4351         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4352         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4353                         &cap_idx) == NULL)
4354                 return TEST_SKIPPED;
4355
4356         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4357                 return TEST_SKIPPED;
4358
4359         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4360                 return TEST_SKIPPED;
4361
4362         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4363
4364         uint64_t feat_flags = dev_info.feature_flags;
4365
4366         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4367                 printf("Device doesn't support out-of-place scatter-gather "
4368                                 "in both input and output mbufs. "
4369                                 "Test Skipped.\n");
4370                 return TEST_SKIPPED;
4371         }
4372
4373         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4374                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4375                 printf("Device does not support RAW data-path APIs.\n");
4376                 return -ENOTSUP;
4377         }
4378
4379         /* Create SNOW 3G session */
4380         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4381                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4382                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4383                                         tdata->key.data, tdata->key.len,
4384                                         tdata->cipher_iv.len);
4385         if (retval < 0)
4386                 return retval;
4387
4388         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4389         /* Append data which is padded to a multiple of */
4390         /* the algorithms block size */
4391         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4392
4393         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4394                         plaintext_pad_len, 10, 0);
4395         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4396                         plaintext_pad_len, 3, 0);
4397
4398         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4399                         "Failed to allocate input buffer in mempool");
4400         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4401                         "Failed to allocate output buffer in mempool");
4402
4403         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4404
4405         /* Create SNOW 3G operation */
4406         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4407                                         tdata->cipher_iv.len,
4408                                         tdata->validCipherLenInBits.len,
4409                                         0);
4410         if (retval < 0)
4411                 return retval;
4412
4413         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4414                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4415                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4416         else
4417                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4418                                                 ut_params->op);
4419         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4420
4421         ut_params->obuf = ut_params->op->sym->m_dst;
4422         if (ut_params->obuf)
4423                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4424                                 plaintext_len, buffer);
4425         else
4426                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4427                                 plaintext_len, buffer);
4428
4429         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4430
4431         /* Validate obuf */
4432         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4433                 ciphertext,
4434                 tdata->ciphertext.data,
4435                 tdata->validDataLenInBits.len,
4436                 "SNOW 3G Ciphertext data not as expected");
4437
4438         return 0;
4439 }
4440
4441 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4442 static void
4443 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4444 {
4445         uint8_t curr_byte, prev_byte;
4446         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4447         uint8_t lower_byte_mask = (1 << offset) - 1;
4448         unsigned i;
4449
4450         prev_byte = buffer[0];
4451         buffer[0] >>= offset;
4452
4453         for (i = 1; i < length_in_bytes; i++) {
4454                 curr_byte = buffer[i];
4455                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4456                                 (curr_byte >> offset);
4457                 prev_byte = curr_byte;
4458         }
4459 }
4460
4461 static int
4462 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4463 {
4464         struct crypto_testsuite_params *ts_params = &testsuite_params;
4465         struct crypto_unittest_params *ut_params = &unittest_params;
4466         uint8_t *plaintext, *ciphertext;
4467         int retval;
4468         uint32_t plaintext_len;
4469         uint32_t plaintext_pad_len;
4470         uint8_t extra_offset = 4;
4471         uint8_t *expected_ciphertext_shifted;
4472         struct rte_cryptodev_info dev_info;
4473
4474         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4475         uint64_t feat_flags = dev_info.feature_flags;
4476
4477         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4478                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4479                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4480                 return TEST_SKIPPED;
4481         }
4482
4483         /* Verify the capabilities */
4484         struct rte_cryptodev_sym_capability_idx cap_idx;
4485         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4486         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4487         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4488                         &cap_idx) == NULL)
4489                 return TEST_SKIPPED;
4490
4491         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4492                 return TEST_SKIPPED;
4493
4494         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4495                 return TEST_SKIPPED;
4496
4497         /* Create SNOW 3G session */
4498         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4499                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4500                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4501                                         tdata->key.data, tdata->key.len,
4502                                         tdata->cipher_iv.len);
4503         if (retval < 0)
4504                 return retval;
4505
4506         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4507         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4508
4509         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4510                         "Failed to allocate input buffer in mempool");
4511         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4512                         "Failed to allocate output buffer in mempool");
4513
4514         /* Clear mbuf payload */
4515         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4516                rte_pktmbuf_tailroom(ut_params->ibuf));
4517
4518         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4519         /*
4520          * Append data which is padded to a
4521          * multiple of the algorithms block size
4522          */
4523         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4524
4525         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4526                                                 plaintext_pad_len);
4527
4528         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4529
4530         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4531         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4532
4533 #ifdef RTE_APP_TEST_DEBUG
4534         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4535 #endif
4536         /* Create SNOW 3G operation */
4537         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4538                                         tdata->cipher_iv.len,
4539                                         tdata->validCipherLenInBits.len,
4540                                         extra_offset);
4541         if (retval < 0)
4542                 return retval;
4543
4544         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4545                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4546                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4547         else
4548                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4549                                                 ut_params->op);
4550         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4551
4552         ut_params->obuf = ut_params->op->sym->m_dst;
4553         if (ut_params->obuf)
4554                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4555         else
4556                 ciphertext = plaintext;
4557
4558 #ifdef RTE_APP_TEST_DEBUG
4559         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4560 #endif
4561
4562         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4563
4564         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4565                         "failed to reserve memory for ciphertext shifted\n");
4566
4567         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4568                         ceil_byte_length(tdata->ciphertext.len));
4569         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4570                         extra_offset);
4571         /* Validate obuf */
4572         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4573                 ciphertext,
4574                 expected_ciphertext_shifted,
4575                 tdata->validDataLenInBits.len,
4576                 extra_offset,
4577                 "SNOW 3G Ciphertext data not as expected");
4578         return 0;
4579 }
4580
4581 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4582 {
4583         struct crypto_testsuite_params *ts_params = &testsuite_params;
4584         struct crypto_unittest_params *ut_params = &unittest_params;
4585
4586         int retval;
4587
4588         uint8_t *plaintext, *ciphertext;
4589         unsigned ciphertext_pad_len;
4590         unsigned ciphertext_len;
4591         struct rte_cryptodev_info dev_info;
4592
4593         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4594         uint64_t feat_flags = dev_info.feature_flags;
4595
4596         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4597                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4598                 printf("Device doesn't support RAW data-path APIs.\n");
4599                 return TEST_SKIPPED;
4600         }
4601
4602         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4603                 return TEST_SKIPPED;
4604
4605         /* Verify the capabilities */
4606         struct rte_cryptodev_sym_capability_idx cap_idx;
4607         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4608         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4609         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4610                         &cap_idx) == NULL)
4611                 return TEST_SKIPPED;
4612
4613         /* Create SNOW 3G session */
4614         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4615                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4616                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4617                                         tdata->key.data, tdata->key.len,
4618                                         tdata->cipher_iv.len);
4619         if (retval < 0)
4620                 return retval;
4621
4622         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4623
4624         /* Clear mbuf payload */
4625         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4626                rte_pktmbuf_tailroom(ut_params->ibuf));
4627
4628         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4629         /* Append data which is padded to a multiple of */
4630         /* the algorithms block size */
4631         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4632         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4633                                 ciphertext_pad_len);
4634         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4635
4636         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4637
4638         /* Create SNOW 3G operation */
4639         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4640                                         tdata->cipher_iv.len,
4641                                         tdata->validCipherLenInBits.len,
4642                                         tdata->cipher.offset_bits);
4643         if (retval < 0)
4644                 return retval;
4645
4646         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4647                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4648                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4649         else
4650                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4651                                                 ut_params->op);
4652         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4653         ut_params->obuf = ut_params->op->sym->m_dst;
4654         if (ut_params->obuf)
4655                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4656         else
4657                 plaintext = ciphertext;
4658
4659         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4660
4661         /* Validate obuf */
4662         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4663                                 tdata->plaintext.data,
4664                                 tdata->validDataLenInBits.len,
4665                                 "SNOW 3G Plaintext data not as expected");
4666         return 0;
4667 }
4668
4669 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4670 {
4671         struct crypto_testsuite_params *ts_params = &testsuite_params;
4672         struct crypto_unittest_params *ut_params = &unittest_params;
4673
4674         int retval;
4675
4676         uint8_t *plaintext, *ciphertext;
4677         unsigned ciphertext_pad_len;
4678         unsigned ciphertext_len;
4679         struct rte_cryptodev_info dev_info;
4680
4681         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4682         uint64_t feat_flags = dev_info.feature_flags;
4683
4684         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4685                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4686                 printf("Device does not support RAW data-path APIs.\n");
4687                 return -ENOTSUP;
4688         }
4689         /* Verify the capabilities */
4690         struct rte_cryptodev_sym_capability_idx cap_idx;
4691         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4692         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4693         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4694                         &cap_idx) == NULL)
4695                 return TEST_SKIPPED;
4696
4697         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4698                 return TEST_SKIPPED;
4699
4700         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4701                 return TEST_SKIPPED;
4702
4703         /* Create SNOW 3G session */
4704         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4705                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4706                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4707                                         tdata->key.data, tdata->key.len,
4708                                         tdata->cipher_iv.len);
4709         if (retval < 0)
4710                 return retval;
4711
4712         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4713         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4714
4715         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4716                         "Failed to allocate input buffer");
4717         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4718                         "Failed to allocate output buffer");
4719
4720         /* Clear mbuf payload */
4721         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4722                rte_pktmbuf_tailroom(ut_params->ibuf));
4723
4724         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4725                        rte_pktmbuf_tailroom(ut_params->obuf));
4726
4727         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4728         /* Append data which is padded to a multiple of */
4729         /* the algorithms block size */
4730         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4731         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4732                                 ciphertext_pad_len);
4733         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4734         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4735
4736         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4737
4738         /* Create SNOW 3G operation */
4739         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4740                                         tdata->cipher_iv.len,
4741                                         tdata->validCipherLenInBits.len,
4742                                         0);
4743         if (retval < 0)
4744                 return retval;
4745
4746         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4747                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4748                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4749         else
4750                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4751                                                 ut_params->op);
4752         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4753         ut_params->obuf = ut_params->op->sym->m_dst;
4754         if (ut_params->obuf)
4755                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4756         else
4757                 plaintext = ciphertext;
4758
4759         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4760
4761         /* Validate obuf */
4762         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4763                                 tdata->plaintext.data,
4764                                 tdata->validDataLenInBits.len,
4765                                 "SNOW 3G Plaintext data not as expected");
4766         return 0;
4767 }
4768
4769 static int
4770 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4771 {
4772         struct crypto_testsuite_params *ts_params = &testsuite_params;
4773         struct crypto_unittest_params *ut_params = &unittest_params;
4774
4775         int retval;
4776
4777         uint8_t *plaintext, *ciphertext;
4778         unsigned int plaintext_pad_len;
4779         unsigned int plaintext_len;
4780
4781         struct rte_cryptodev_info dev_info;
4782         struct rte_cryptodev_sym_capability_idx cap_idx;
4783
4784         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4785         uint64_t feat_flags = dev_info.feature_flags;
4786
4787         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4788                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4789                         (tdata->validDataLenInBits.len % 8 != 0))) {
4790                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4791                 return TEST_SKIPPED;
4792         }
4793
4794         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4795                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4796                 printf("Device doesn't support RAW data-path APIs.\n");
4797                 return TEST_SKIPPED;
4798         }
4799
4800         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4801                 return TEST_SKIPPED;
4802
4803         /* Check if device supports ZUC EEA3 */
4804         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4805         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4806
4807         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4808                         &cap_idx) == NULL)
4809                 return TEST_SKIPPED;
4810
4811         /* Check if device supports ZUC EIA3 */
4812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4813         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4814
4815         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4816                         &cap_idx) == NULL)
4817                 return TEST_SKIPPED;
4818
4819         /* Create ZUC session */
4820         retval = create_zuc_cipher_auth_encrypt_generate_session(
4821                         ts_params->valid_devs[0],
4822                         tdata);
4823         if (retval != 0)
4824                 return retval;
4825         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4826
4827         /* clear mbuf payload */
4828         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4829                         rte_pktmbuf_tailroom(ut_params->ibuf));
4830
4831         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4832         /* Append data which is padded to a multiple of */
4833         /* the algorithms block size */
4834         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4835         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4836                                 plaintext_pad_len);
4837         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4838
4839         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4840
4841         /* Create ZUC operation */
4842         retval = create_zuc_cipher_hash_generate_operation(tdata);
4843         if (retval < 0)
4844                 return retval;
4845
4846         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4847                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4848                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4849         else
4850                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4851                         ut_params->op);
4852         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4853         ut_params->obuf = ut_params->op->sym->m_src;
4854         if (ut_params->obuf)
4855                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4856         else
4857                 ciphertext = plaintext;
4858
4859         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4860         /* Validate obuf */
4861         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4862                         ciphertext,
4863                         tdata->ciphertext.data,
4864                         tdata->validDataLenInBits.len,
4865                         "ZUC Ciphertext data not as expected");
4866
4867         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4868             + plaintext_pad_len;
4869
4870         /* Validate obuf */
4871         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4872                         ut_params->digest,
4873                         tdata->digest.data,
4874                         4,
4875                         "ZUC Generated auth tag not as expected");
4876         return 0;
4877 }
4878
4879 static int
4880 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4881 {
4882         struct crypto_testsuite_params *ts_params = &testsuite_params;
4883         struct crypto_unittest_params *ut_params = &unittest_params;
4884
4885         int retval;
4886
4887         uint8_t *plaintext, *ciphertext;
4888         unsigned plaintext_pad_len;
4889         unsigned plaintext_len;
4890         struct rte_cryptodev_info dev_info;
4891
4892         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4893         uint64_t feat_flags = dev_info.feature_flags;
4894
4895         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4896                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4897                 printf("Device doesn't support RAW data-path APIs.\n");
4898                 return TEST_SKIPPED;
4899         }
4900
4901         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4902                 return TEST_SKIPPED;
4903
4904         /* Verify the capabilities */
4905         struct rte_cryptodev_sym_capability_idx cap_idx;
4906         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4907         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4908         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4909                         &cap_idx) == NULL)
4910                 return TEST_SKIPPED;
4911         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4912         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4913         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4914                         &cap_idx) == NULL)
4915                 return TEST_SKIPPED;
4916
4917         /* Create SNOW 3G session */
4918         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4919                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4920                         RTE_CRYPTO_AUTH_OP_GENERATE,
4921                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4922                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4923                         tdata->key.data, tdata->key.len,
4924                         tdata->auth_iv.len, tdata->digest.len,
4925                         tdata->cipher_iv.len);
4926         if (retval != 0)
4927                 return retval;
4928         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4929
4930         /* clear mbuf payload */
4931         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4932                         rte_pktmbuf_tailroom(ut_params->ibuf));
4933
4934         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4935         /* Append data which is padded to a multiple of */
4936         /* the algorithms block size */
4937         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4938         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4939                                 plaintext_pad_len);
4940         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4941
4942         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4943
4944         /* Create SNOW 3G operation */
4945         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4946                         tdata->digest.len, tdata->auth_iv.data,
4947                         tdata->auth_iv.len,
4948                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4949                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4950                         tdata->validCipherLenInBits.len,
4951                         0,
4952                         tdata->validAuthLenInBits.len,
4953                         0
4954                         );
4955         if (retval < 0)
4956                 return retval;
4957
4958         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4959                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4960                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4961         else
4962                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4963                         ut_params->op);
4964         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4965         ut_params->obuf = ut_params->op->sym->m_src;
4966         if (ut_params->obuf)
4967                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4968         else
4969                 ciphertext = plaintext;
4970
4971         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4972         /* Validate obuf */
4973         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4974                         ciphertext,
4975                         tdata->ciphertext.data,
4976                         tdata->validDataLenInBits.len,
4977                         "SNOW 3G Ciphertext data not as expected");
4978
4979         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4980             + plaintext_pad_len;
4981
4982         /* Validate obuf */
4983         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4984                         ut_params->digest,
4985                         tdata->digest.data,
4986                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4987                         "SNOW 3G Generated auth tag not as expected");
4988         return 0;
4989 }
4990
4991 static int
4992 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
4993         uint8_t op_mode, uint8_t verify)
4994 {
4995         struct crypto_testsuite_params *ts_params = &testsuite_params;
4996         struct crypto_unittest_params *ut_params = &unittest_params;
4997
4998         int retval;
4999
5000         uint8_t *plaintext = NULL, *ciphertext = NULL;
5001         unsigned int plaintext_pad_len;
5002         unsigned int plaintext_len;
5003         unsigned int ciphertext_pad_len;
5004         unsigned int ciphertext_len;
5005
5006         struct rte_cryptodev_info dev_info;
5007
5008         /* Verify the capabilities */
5009         struct rte_cryptodev_sym_capability_idx cap_idx;
5010         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5011         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5012         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5013                         &cap_idx) == NULL)
5014                 return TEST_SKIPPED;
5015         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5016         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5017         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5018                         &cap_idx) == NULL)
5019                 return TEST_SKIPPED;
5020
5021         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5022                 return TEST_SKIPPED;
5023
5024         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5025
5026         uint64_t feat_flags = dev_info.feature_flags;
5027
5028         if (op_mode == OUT_OF_PLACE) {
5029                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5030                         printf("Device doesn't support digest encrypted.\n");
5031                         return TEST_SKIPPED;
5032                 }
5033                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5034                         return TEST_SKIPPED;
5035         }
5036
5037         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5038                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5039                 printf("Device doesn't support RAW data-path APIs.\n");
5040                 return TEST_SKIPPED;
5041         }
5042
5043         /* Create SNOW 3G session */
5044         retval = create_wireless_algo_auth_cipher_session(
5045                         ts_params->valid_devs[0],
5046                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5047                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5048                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5049                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5050                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5051                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5052                         tdata->key.data, tdata->key.len,
5053                         tdata->auth_iv.len, tdata->digest.len,
5054                         tdata->cipher_iv.len);
5055         if (retval != 0)
5056                 return retval;
5057
5058         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5059         if (op_mode == OUT_OF_PLACE)
5060                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5061
5062         /* clear mbuf payload */
5063         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5064                 rte_pktmbuf_tailroom(ut_params->ibuf));
5065         if (op_mode == OUT_OF_PLACE)
5066                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5067                         rte_pktmbuf_tailroom(ut_params->obuf));
5068
5069         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5070         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5071         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5072         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5073
5074         if (verify) {
5075                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5076                                         ciphertext_pad_len);
5077                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5078                 if (op_mode == OUT_OF_PLACE)
5079                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5080                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5081                         ciphertext_len);
5082         } else {
5083                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5084                                         plaintext_pad_len);
5085                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5086                 if (op_mode == OUT_OF_PLACE)
5087                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5088                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5089         }
5090
5091         /* Create SNOW 3G operation */
5092         retval = create_wireless_algo_auth_cipher_operation(
5093                 tdata->digest.data, tdata->digest.len,
5094                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5095                 tdata->auth_iv.data, tdata->auth_iv.len,
5096                 (tdata->digest.offset_bytes == 0 ?
5097                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5098                         : tdata->digest.offset_bytes),
5099                 tdata->validCipherLenInBits.len,
5100                 tdata->cipher.offset_bits,
5101                 tdata->validAuthLenInBits.len,
5102                 tdata->auth.offset_bits,
5103                 op_mode, 0, verify);
5104
5105         if (retval < 0)
5106                 return retval;
5107
5108         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5109                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5110                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5111         else
5112                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5113                         ut_params->op);
5114
5115         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5116
5117         ut_params->obuf = (op_mode == IN_PLACE ?
5118                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5119
5120         if (verify) {
5121                 if (ut_params->obuf)
5122                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5123                                                         uint8_t *);
5124                 else
5125                         plaintext = ciphertext +
5126                                 (tdata->cipher.offset_bits >> 3);
5127
5128                 debug_hexdump(stdout, "plaintext:", plaintext,
5129                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5130                 debug_hexdump(stdout, "plaintext expected:",
5131                         tdata->plaintext.data,
5132                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5133         } else {
5134                 if (ut_params->obuf)
5135                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5136                                                         uint8_t *);
5137                 else
5138                         ciphertext = plaintext;
5139
5140                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5141                         ciphertext_len);
5142                 debug_hexdump(stdout, "ciphertext expected:",
5143                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5144
5145                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5146                         + (tdata->digest.offset_bytes == 0 ?
5147                 plaintext_pad_len : tdata->digest.offset_bytes);
5148
5149                 debug_hexdump(stdout, "digest:", ut_params->digest,
5150                         tdata->digest.len);
5151                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5152                                 tdata->digest.len);
5153         }
5154
5155         /* Validate obuf */
5156         if (verify) {
5157                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5158                         plaintext,
5159                         tdata->plaintext.data,
5160                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5161                          (tdata->digest.len << 3)),
5162                         tdata->cipher.offset_bits,
5163                         "SNOW 3G Plaintext data not as expected");
5164         } else {
5165                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5166                         ciphertext,
5167                         tdata->ciphertext.data,
5168                         (tdata->validDataLenInBits.len -
5169                          tdata->cipher.offset_bits),
5170                         tdata->cipher.offset_bits,
5171                         "SNOW 3G Ciphertext data not as expected");
5172
5173                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5174                         ut_params->digest,
5175                         tdata->digest.data,
5176                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5177                         "SNOW 3G Generated auth tag not as expected");
5178         }
5179         return 0;
5180 }
5181
5182 static int
5183 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5184         uint8_t op_mode, uint8_t verify)
5185 {
5186         struct crypto_testsuite_params *ts_params = &testsuite_params;
5187         struct crypto_unittest_params *ut_params = &unittest_params;
5188
5189         int retval;
5190
5191         const uint8_t *plaintext = NULL;
5192         const uint8_t *ciphertext = NULL;
5193         const uint8_t *digest = NULL;
5194         unsigned int plaintext_pad_len;
5195         unsigned int plaintext_len;
5196         unsigned int ciphertext_pad_len;
5197         unsigned int ciphertext_len;
5198         uint8_t buffer[10000];
5199         uint8_t digest_buffer[10000];
5200
5201         struct rte_cryptodev_info dev_info;
5202
5203         /* Verify the capabilities */
5204         struct rte_cryptodev_sym_capability_idx cap_idx;
5205         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5206         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5207         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5208                         &cap_idx) == NULL)
5209                 return TEST_SKIPPED;
5210         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5211         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5212         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5213                         &cap_idx) == NULL)
5214                 return TEST_SKIPPED;
5215
5216         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5217                 return TEST_SKIPPED;
5218
5219         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5220
5221         uint64_t feat_flags = dev_info.feature_flags;
5222
5223         if (op_mode == IN_PLACE) {
5224                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5225                         printf("Device doesn't support in-place scatter-gather "
5226                                         "in both input and output mbufs.\n");
5227                         return TEST_SKIPPED;
5228                 }
5229                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5230                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5231                         printf("Device doesn't support RAW data-path APIs.\n");
5232                         return TEST_SKIPPED;
5233                 }
5234         } else {
5235                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5236                         return TEST_SKIPPED;
5237                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5238                         printf("Device doesn't support out-of-place scatter-gather "
5239                                         "in both input and output mbufs.\n");
5240                         return TEST_SKIPPED;
5241                 }
5242                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5243                         printf("Device doesn't support digest encrypted.\n");
5244                         return TEST_SKIPPED;
5245                 }
5246         }
5247
5248         /* Create SNOW 3G session */
5249         retval = create_wireless_algo_auth_cipher_session(
5250                         ts_params->valid_devs[0],
5251                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5252                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5253                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5254                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5255                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5256                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5257                         tdata->key.data, tdata->key.len,
5258                         tdata->auth_iv.len, tdata->digest.len,
5259                         tdata->cipher_iv.len);
5260
5261         if (retval != 0)
5262                 return retval;
5263
5264         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5265         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5266         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5267         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5268
5269         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5270                         plaintext_pad_len, 15, 0);
5271         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5272                         "Failed to allocate input buffer in mempool");
5273
5274         if (op_mode == OUT_OF_PLACE) {
5275                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5276                                 plaintext_pad_len, 15, 0);
5277                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5278                                 "Failed to allocate output buffer in mempool");
5279         }
5280
5281         if (verify) {
5282                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5283                         tdata->ciphertext.data);
5284                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5285                                         ciphertext_len, buffer);
5286                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5287                         ciphertext_len);
5288         } else {
5289                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5290                         tdata->plaintext.data);
5291                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5292                                         plaintext_len, buffer);
5293                 debug_hexdump(stdout, "plaintext:", plaintext,
5294                         plaintext_len);
5295         }
5296         memset(buffer, 0, sizeof(buffer));
5297
5298         /* Create SNOW 3G operation */
5299         retval = create_wireless_algo_auth_cipher_operation(
5300                 tdata->digest.data, tdata->digest.len,
5301                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5302                 tdata->auth_iv.data, tdata->auth_iv.len,
5303                 (tdata->digest.offset_bytes == 0 ?
5304                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5305                         : tdata->digest.offset_bytes),
5306                 tdata->validCipherLenInBits.len,
5307                 tdata->cipher.offset_bits,
5308                 tdata->validAuthLenInBits.len,
5309                 tdata->auth.offset_bits,
5310                 op_mode, 1, verify);
5311
5312         if (retval < 0)
5313                 return retval;
5314
5315         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5316                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5317                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5318         else
5319                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5320                         ut_params->op);
5321
5322         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5323
5324         ut_params->obuf = (op_mode == IN_PLACE ?
5325                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5326
5327         if (verify) {
5328                 if (ut_params->obuf)
5329                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5330                                         plaintext_len, buffer);
5331                 else
5332                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5333                                         plaintext_len, buffer);
5334
5335                 debug_hexdump(stdout, "plaintext:", plaintext,
5336                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5337                 debug_hexdump(stdout, "plaintext expected:",
5338                         tdata->plaintext.data,
5339                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5340         } else {
5341                 if (ut_params->obuf)
5342                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5343                                         ciphertext_len, buffer);
5344                 else
5345                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5346                                         ciphertext_len, buffer);
5347
5348                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5349                         ciphertext_len);
5350                 debug_hexdump(stdout, "ciphertext expected:",
5351                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5352
5353                 if (ut_params->obuf)
5354                         digest = rte_pktmbuf_read(ut_params->obuf,
5355                                 (tdata->digest.offset_bytes == 0 ?
5356                                 plaintext_pad_len : tdata->digest.offset_bytes),
5357                                 tdata->digest.len, digest_buffer);
5358                 else
5359                         digest = rte_pktmbuf_read(ut_params->ibuf,
5360                                 (tdata->digest.offset_bytes == 0 ?
5361                                 plaintext_pad_len : tdata->digest.offset_bytes),
5362                                 tdata->digest.len, digest_buffer);
5363
5364                 debug_hexdump(stdout, "digest:", digest,
5365                         tdata->digest.len);
5366                 debug_hexdump(stdout, "digest expected:",
5367                         tdata->digest.data, tdata->digest.len);
5368         }
5369
5370         /* Validate obuf */
5371         if (verify) {
5372                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5373                         plaintext,
5374                         tdata->plaintext.data,
5375                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5376                          (tdata->digest.len << 3)),
5377                         tdata->cipher.offset_bits,
5378                         "SNOW 3G Plaintext data not as expected");
5379         } else {
5380                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5381                         ciphertext,
5382                         tdata->ciphertext.data,
5383                         (tdata->validDataLenInBits.len -
5384                          tdata->cipher.offset_bits),
5385                         tdata->cipher.offset_bits,
5386                         "SNOW 3G Ciphertext data not as expected");
5387
5388                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5389                         digest,
5390                         tdata->digest.data,
5391                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5392                         "SNOW 3G Generated auth tag not as expected");
5393         }
5394         return 0;
5395 }
5396
5397 static int
5398 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5399         uint8_t op_mode, uint8_t verify)
5400 {
5401         struct crypto_testsuite_params *ts_params = &testsuite_params;
5402         struct crypto_unittest_params *ut_params = &unittest_params;
5403
5404         int retval;
5405
5406         uint8_t *plaintext = NULL, *ciphertext = NULL;
5407         unsigned int plaintext_pad_len;
5408         unsigned int plaintext_len;
5409         unsigned int ciphertext_pad_len;
5410         unsigned int ciphertext_len;
5411
5412         struct rte_cryptodev_info dev_info;
5413
5414         /* Verify the capabilities */
5415         struct rte_cryptodev_sym_capability_idx cap_idx;
5416         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5417         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5418         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5419                         &cap_idx) == NULL)
5420                 return TEST_SKIPPED;
5421         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5422         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5423         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5424                         &cap_idx) == NULL)
5425                 return TEST_SKIPPED;
5426
5427         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5428
5429         uint64_t feat_flags = dev_info.feature_flags;
5430
5431         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5432                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5433                 printf("Device doesn't support RAW data-path APIs.\n");
5434                 return TEST_SKIPPED;
5435         }
5436
5437         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5438                 return TEST_SKIPPED;
5439
5440         if (op_mode == OUT_OF_PLACE) {
5441                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5442                         return TEST_SKIPPED;
5443                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5444                         printf("Device doesn't support digest encrypted.\n");
5445                         return TEST_SKIPPED;
5446                 }
5447         }
5448
5449         /* Create KASUMI session */
5450         retval = create_wireless_algo_auth_cipher_session(
5451                         ts_params->valid_devs[0],
5452                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5453                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5454                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5455                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5456                         RTE_CRYPTO_AUTH_KASUMI_F9,
5457                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5458                         tdata->key.data, tdata->key.len,
5459                         0, tdata->digest.len,
5460                         tdata->cipher_iv.len);
5461
5462         if (retval != 0)
5463                 return retval;
5464
5465         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5466         if (op_mode == OUT_OF_PLACE)
5467                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5468
5469         /* clear mbuf payload */
5470         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5471                 rte_pktmbuf_tailroom(ut_params->ibuf));
5472         if (op_mode == OUT_OF_PLACE)
5473                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5474                         rte_pktmbuf_tailroom(ut_params->obuf));
5475
5476         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5477         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5478         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5479         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5480
5481         if (verify) {
5482                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5483                                         ciphertext_pad_len);
5484                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5485                 if (op_mode == OUT_OF_PLACE)
5486                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5487                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5488                         ciphertext_len);
5489         } else {
5490                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5491                                         plaintext_pad_len);
5492                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5493                 if (op_mode == OUT_OF_PLACE)
5494                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5495                 debug_hexdump(stdout, "plaintext:", plaintext,
5496                         plaintext_len);
5497         }
5498
5499         /* Create KASUMI operation */
5500         retval = create_wireless_algo_auth_cipher_operation(
5501                 tdata->digest.data, tdata->digest.len,
5502                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5503                 NULL, 0,
5504                 (tdata->digest.offset_bytes == 0 ?
5505                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5506                         : tdata->digest.offset_bytes),
5507                 tdata->validCipherLenInBits.len,
5508                 tdata->validCipherOffsetInBits.len,
5509                 tdata->validAuthLenInBits.len,
5510                 0,
5511                 op_mode, 0, verify);
5512
5513         if (retval < 0)
5514                 return retval;
5515
5516         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5517                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5518                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5519         else
5520                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5521                         ut_params->op);
5522
5523         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5524
5525         ut_params->obuf = (op_mode == IN_PLACE ?
5526                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5527
5528
5529         if (verify) {
5530                 if (ut_params->obuf)
5531                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5532                                                         uint8_t *);
5533                 else
5534                         plaintext = ciphertext;
5535
5536                 debug_hexdump(stdout, "plaintext:", plaintext,
5537                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5538                 debug_hexdump(stdout, "plaintext expected:",
5539                         tdata->plaintext.data,
5540                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5541         } else {
5542                 if (ut_params->obuf)
5543                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5544                                                         uint8_t *);
5545                 else
5546                         ciphertext = plaintext;
5547
5548                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5549                         ciphertext_len);
5550                 debug_hexdump(stdout, "ciphertext expected:",
5551                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5552
5553                 ut_params->digest = rte_pktmbuf_mtod(
5554                         ut_params->obuf, uint8_t *) +
5555                         (tdata->digest.offset_bytes == 0 ?
5556                         plaintext_pad_len : tdata->digest.offset_bytes);
5557
5558                 debug_hexdump(stdout, "digest:", ut_params->digest,
5559                         tdata->digest.len);
5560                 debug_hexdump(stdout, "digest expected:",
5561                         tdata->digest.data, tdata->digest.len);
5562         }
5563
5564         /* Validate obuf */
5565         if (verify) {
5566                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5567                         plaintext,
5568                         tdata->plaintext.data,
5569                         tdata->plaintext.len >> 3,
5570                         "KASUMI Plaintext data not as expected");
5571         } else {
5572                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5573                         ciphertext,
5574                         tdata->ciphertext.data,
5575                         tdata->ciphertext.len >> 3,
5576                         "KASUMI Ciphertext data not as expected");
5577
5578                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5579                         ut_params->digest,
5580                         tdata->digest.data,
5581                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5582                         "KASUMI Generated auth tag not as expected");
5583         }
5584         return 0;
5585 }
5586
5587 static int
5588 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5589         uint8_t op_mode, uint8_t verify)
5590 {
5591         struct crypto_testsuite_params *ts_params = &testsuite_params;
5592         struct crypto_unittest_params *ut_params = &unittest_params;
5593
5594         int retval;
5595
5596         const uint8_t *plaintext = NULL;
5597         const uint8_t *ciphertext = NULL;
5598         const uint8_t *digest = NULL;
5599         unsigned int plaintext_pad_len;
5600         unsigned int plaintext_len;
5601         unsigned int ciphertext_pad_len;
5602         unsigned int ciphertext_len;
5603         uint8_t buffer[10000];
5604         uint8_t digest_buffer[10000];
5605
5606         struct rte_cryptodev_info dev_info;
5607
5608         /* Verify the capabilities */
5609         struct rte_cryptodev_sym_capability_idx cap_idx;
5610         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5611         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5612         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5613                         &cap_idx) == NULL)
5614                 return TEST_SKIPPED;
5615         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5616         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5617         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5618                         &cap_idx) == NULL)
5619                 return TEST_SKIPPED;
5620
5621         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5622                 return TEST_SKIPPED;
5623
5624         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5625
5626         uint64_t feat_flags = dev_info.feature_flags;
5627
5628         if (op_mode == IN_PLACE) {
5629                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5630                         printf("Device doesn't support in-place scatter-gather "
5631                                         "in both input and output mbufs.\n");
5632                         return TEST_SKIPPED;
5633                 }
5634                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5635                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5636                         printf("Device doesn't support RAW data-path APIs.\n");
5637                         return TEST_SKIPPED;
5638                 }
5639         } else {
5640                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5641                         return TEST_SKIPPED;
5642                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5643                         printf("Device doesn't support out-of-place scatter-gather "
5644                                         "in both input and output mbufs.\n");
5645                         return TEST_SKIPPED;
5646                 }
5647                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5648                         printf("Device doesn't support digest encrypted.\n");
5649                         return TEST_SKIPPED;
5650                 }
5651         }
5652
5653         /* Create KASUMI session */
5654         retval = create_wireless_algo_auth_cipher_session(
5655                         ts_params->valid_devs[0],
5656                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5657                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5658                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5659                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5660                         RTE_CRYPTO_AUTH_KASUMI_F9,
5661                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5662                         tdata->key.data, tdata->key.len,
5663                         0, tdata->digest.len,
5664                         tdata->cipher_iv.len);
5665
5666         if (retval != 0)
5667                 return retval;
5668
5669         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5670         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5671         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5672         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5673
5674         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5675                         plaintext_pad_len, 15, 0);
5676         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5677                         "Failed to allocate input buffer in mempool");
5678
5679         if (op_mode == OUT_OF_PLACE) {
5680                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5681                                 plaintext_pad_len, 15, 0);
5682                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5683                                 "Failed to allocate output buffer in mempool");
5684         }
5685
5686         if (verify) {
5687                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5688                         tdata->ciphertext.data);
5689                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5690                                         ciphertext_len, buffer);
5691                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5692                         ciphertext_len);
5693         } else {
5694                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5695                         tdata->plaintext.data);
5696                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5697                                         plaintext_len, buffer);
5698                 debug_hexdump(stdout, "plaintext:", plaintext,
5699                         plaintext_len);
5700         }
5701         memset(buffer, 0, sizeof(buffer));
5702
5703         /* Create KASUMI operation */
5704         retval = create_wireless_algo_auth_cipher_operation(
5705                 tdata->digest.data, tdata->digest.len,
5706                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5707                 NULL, 0,
5708                 (tdata->digest.offset_bytes == 0 ?
5709                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5710                         : tdata->digest.offset_bytes),
5711                 tdata->validCipherLenInBits.len,
5712                 tdata->validCipherOffsetInBits.len,
5713                 tdata->validAuthLenInBits.len,
5714                 0,
5715                 op_mode, 1, verify);
5716
5717         if (retval < 0)
5718                 return retval;
5719
5720         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5721                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5722                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5723         else
5724                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5725                         ut_params->op);
5726
5727         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5728
5729         ut_params->obuf = (op_mode == IN_PLACE ?
5730                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5731
5732         if (verify) {
5733                 if (ut_params->obuf)
5734                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5735                                         plaintext_len, buffer);
5736                 else
5737                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5738                                         plaintext_len, buffer);
5739
5740                 debug_hexdump(stdout, "plaintext:", plaintext,
5741                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5742                 debug_hexdump(stdout, "plaintext expected:",
5743                         tdata->plaintext.data,
5744                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5745         } else {
5746                 if (ut_params->obuf)
5747                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5748                                         ciphertext_len, buffer);
5749                 else
5750                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5751                                         ciphertext_len, buffer);
5752
5753                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5754                         ciphertext_len);
5755                 debug_hexdump(stdout, "ciphertext expected:",
5756                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5757
5758                 if (ut_params->obuf)
5759                         digest = rte_pktmbuf_read(ut_params->obuf,
5760                                 (tdata->digest.offset_bytes == 0 ?
5761                                 plaintext_pad_len : tdata->digest.offset_bytes),
5762                                 tdata->digest.len, digest_buffer);
5763                 else
5764                         digest = rte_pktmbuf_read(ut_params->ibuf,
5765                                 (tdata->digest.offset_bytes == 0 ?
5766                                 plaintext_pad_len : tdata->digest.offset_bytes),
5767                                 tdata->digest.len, digest_buffer);
5768
5769                 debug_hexdump(stdout, "digest:", digest,
5770                         tdata->digest.len);
5771                 debug_hexdump(stdout, "digest expected:",
5772                         tdata->digest.data, tdata->digest.len);
5773         }
5774
5775         /* Validate obuf */
5776         if (verify) {
5777                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5778                         plaintext,
5779                         tdata->plaintext.data,
5780                         tdata->plaintext.len >> 3,
5781                         "KASUMI Plaintext data not as expected");
5782         } else {
5783                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5784                         ciphertext,
5785                         tdata->ciphertext.data,
5786                         tdata->validDataLenInBits.len,
5787                         "KASUMI Ciphertext data not as expected");
5788
5789                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5790                         digest,
5791                         tdata->digest.data,
5792                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5793                         "KASUMI Generated auth tag not as expected");
5794         }
5795         return 0;
5796 }
5797
5798 static int
5799 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5800 {
5801         struct crypto_testsuite_params *ts_params = &testsuite_params;
5802         struct crypto_unittest_params *ut_params = &unittest_params;
5803
5804         int retval;
5805
5806         uint8_t *plaintext, *ciphertext;
5807         unsigned plaintext_pad_len;
5808         unsigned plaintext_len;
5809         struct rte_cryptodev_info dev_info;
5810
5811         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5812         uint64_t feat_flags = dev_info.feature_flags;
5813
5814         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5815                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5816                 printf("Device doesn't support RAW data-path APIs.\n");
5817                 return TEST_SKIPPED;
5818         }
5819
5820         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5821                 return TEST_SKIPPED;
5822
5823         /* Verify the capabilities */
5824         struct rte_cryptodev_sym_capability_idx cap_idx;
5825         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5826         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5827         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5828                         &cap_idx) == NULL)
5829                 return TEST_SKIPPED;
5830         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5831         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5832         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5833                         &cap_idx) == NULL)
5834                 return TEST_SKIPPED;
5835
5836         /* Create KASUMI session */
5837         retval = create_wireless_algo_cipher_auth_session(
5838                         ts_params->valid_devs[0],
5839                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5840                         RTE_CRYPTO_AUTH_OP_GENERATE,
5841                         RTE_CRYPTO_AUTH_KASUMI_F9,
5842                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5843                         tdata->key.data, tdata->key.len,
5844                         0, tdata->digest.len,
5845                         tdata->cipher_iv.len);
5846         if (retval != 0)
5847                 return retval;
5848
5849         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5850
5851         /* clear mbuf payload */
5852         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5853                         rte_pktmbuf_tailroom(ut_params->ibuf));
5854
5855         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5856         /* Append data which is padded to a multiple of */
5857         /* the algorithms block size */
5858         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5859         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5860                                 plaintext_pad_len);
5861         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5862
5863         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5864
5865         /* Create KASUMI operation */
5866         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5867                                 tdata->digest.len, NULL, 0,
5868                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5869                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5870                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5871                                 tdata->validCipherOffsetInBits.len,
5872                                 tdata->validAuthLenInBits.len,
5873                                 0
5874                                 );
5875         if (retval < 0)
5876                 return retval;
5877
5878         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5879                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5880                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5881         else
5882                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5883                         ut_params->op);
5884         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5885
5886         if (ut_params->op->sym->m_dst)
5887                 ut_params->obuf = ut_params->op->sym->m_dst;
5888         else
5889                 ut_params->obuf = ut_params->op->sym->m_src;
5890
5891         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5892                                 tdata->validCipherOffsetInBits.len >> 3);
5893
5894         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5895                         + plaintext_pad_len;
5896
5897         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5898                                 (tdata->validCipherOffsetInBits.len >> 3);
5899         /* Validate obuf */
5900         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5901                 ciphertext,
5902                 reference_ciphertext,
5903                 tdata->validCipherLenInBits.len,
5904                 "KASUMI Ciphertext data not as expected");
5905
5906         /* Validate obuf */
5907         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5908                 ut_params->digest,
5909                 tdata->digest.data,
5910                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5911                 "KASUMI Generated auth tag not as expected");
5912         return 0;
5913 }
5914
5915 static int
5916 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5917                         const enum rte_crypto_cipher_algorithm cipher_algo,
5918                         const uint16_t key_size, const uint16_t iv_size)
5919 {
5920         struct rte_cryptodev_sym_capability_idx cap_idx;
5921         const struct rte_cryptodev_symmetric_capability *cap;
5922
5923         /* Check if device supports the algorithm */
5924         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5925         cap_idx.algo.cipher = cipher_algo;
5926
5927         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5928                         &cap_idx);
5929
5930         if (cap == NULL)
5931                 return -1;
5932
5933         /* Check if device supports key size and IV size */
5934         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5935                         iv_size) < 0) {
5936                 return -1;
5937         }
5938
5939         return 0;
5940 }
5941
5942 static int
5943 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5944                         const enum rte_crypto_auth_algorithm auth_algo,
5945                         const uint16_t key_size, const uint16_t iv_size,
5946                         const uint16_t tag_size)
5947 {
5948         struct rte_cryptodev_sym_capability_idx cap_idx;
5949         const struct rte_cryptodev_symmetric_capability *cap;
5950
5951         /* Check if device supports the algorithm */
5952         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5953         cap_idx.algo.auth = auth_algo;
5954
5955         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5956                         &cap_idx);
5957
5958         if (cap == NULL)
5959                 return -1;
5960
5961         /* Check if device supports key size and IV size */
5962         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5963                         tag_size, iv_size) < 0) {
5964                 return -1;
5965         }
5966
5967         return 0;
5968 }
5969
5970 static int
5971 test_zuc_encryption(const struct wireless_test_data *tdata)
5972 {
5973         struct crypto_testsuite_params *ts_params = &testsuite_params;
5974         struct crypto_unittest_params *ut_params = &unittest_params;
5975
5976         int retval;
5977         uint8_t *plaintext, *ciphertext;
5978         unsigned plaintext_pad_len;
5979         unsigned plaintext_len;
5980         struct rte_cryptodev_info dev_info;
5981
5982         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5983         uint64_t feat_flags = dev_info.feature_flags;
5984
5985         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5986                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5987                 printf("Device doesn't support RAW data-path APIs.\n");
5988                 return TEST_SKIPPED;
5989         }
5990
5991         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5992                 return TEST_SKIPPED;
5993
5994         /* Check if device supports ZUC EEA3 */
5995         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
5996                         tdata->key.len, tdata->cipher_iv.len) < 0)
5997                 return TEST_SKIPPED;
5998
5999         /* Create ZUC session */
6000         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6001                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6002                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6003                                         tdata->key.data, tdata->key.len,
6004                                         tdata->cipher_iv.len);
6005         if (retval != 0)
6006                 return retval;
6007
6008         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6009
6010         /* Clear mbuf payload */
6011         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6012                rte_pktmbuf_tailroom(ut_params->ibuf));
6013
6014         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6015         /* Append data which is padded to a multiple */
6016         /* of the algorithms block size */
6017         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6018         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6019                                 plaintext_pad_len);
6020         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6021
6022         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6023
6024         /* Create ZUC operation */
6025         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6026                                         tdata->cipher_iv.len,
6027                                         tdata->plaintext.len,
6028                                         0);
6029         if (retval < 0)
6030                 return retval;
6031
6032         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6033                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6034                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6035         else
6036                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6037                                                 ut_params->op);
6038         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6039
6040         ut_params->obuf = ut_params->op->sym->m_dst;
6041         if (ut_params->obuf)
6042                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6043         else
6044                 ciphertext = plaintext;
6045
6046         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6047
6048         /* Validate obuf */
6049         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6050                 ciphertext,
6051                 tdata->ciphertext.data,
6052                 tdata->validCipherLenInBits.len,
6053                 "ZUC Ciphertext data not as expected");
6054         return 0;
6055 }
6056
6057 static int
6058 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6059 {
6060         struct crypto_testsuite_params *ts_params = &testsuite_params;
6061         struct crypto_unittest_params *ut_params = &unittest_params;
6062
6063         int retval;
6064
6065         unsigned int plaintext_pad_len;
6066         unsigned int plaintext_len;
6067         const uint8_t *ciphertext;
6068         uint8_t ciphertext_buffer[2048];
6069         struct rte_cryptodev_info dev_info;
6070
6071         /* Check if device supports ZUC EEA3 */
6072         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6073                         tdata->key.len, tdata->cipher_iv.len) < 0)
6074                 return TEST_SKIPPED;
6075
6076         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6077                 return TEST_SKIPPED;
6078
6079         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6080
6081         uint64_t feat_flags = dev_info.feature_flags;
6082
6083         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6084                 printf("Device doesn't support in-place scatter-gather. "
6085                                 "Test Skipped.\n");
6086                 return TEST_SKIPPED;
6087         }
6088
6089         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6090                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6091                 printf("Device doesn't support RAW data-path APIs.\n");
6092                 return TEST_SKIPPED;
6093         }
6094
6095         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6096
6097         /* Append data which is padded to a multiple */
6098         /* of the algorithms block size */
6099         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6100
6101         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6102                         plaintext_pad_len, 10, 0);
6103
6104         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6105                         tdata->plaintext.data);
6106
6107         /* Create ZUC session */
6108         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6109                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6110                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6111                         tdata->key.data, tdata->key.len,
6112                         tdata->cipher_iv.len);
6113         if (retval < 0)
6114                 return retval;
6115
6116         /* Clear mbuf payload */
6117
6118         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6119
6120         /* Create ZUC operation */
6121         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6122                         tdata->cipher_iv.len, tdata->plaintext.len,
6123                         0);
6124         if (retval < 0)
6125                 return retval;
6126
6127         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6128                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6129                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6130         else
6131                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6132                                                 ut_params->op);
6133         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6134
6135         ut_params->obuf = ut_params->op->sym->m_dst;
6136         if (ut_params->obuf)
6137                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6138                         0, plaintext_len, ciphertext_buffer);
6139         else
6140                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6141                         0, plaintext_len, ciphertext_buffer);
6142
6143         /* Validate obuf */
6144         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6145
6146         /* Validate obuf */
6147         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6148                 ciphertext,
6149                 tdata->ciphertext.data,
6150                 tdata->validCipherLenInBits.len,
6151                 "ZUC Ciphertext data not as expected");
6152
6153         return 0;
6154 }
6155
6156 static int
6157 test_zuc_authentication(const struct wireless_test_data *tdata)
6158 {
6159         struct crypto_testsuite_params *ts_params = &testsuite_params;
6160         struct crypto_unittest_params *ut_params = &unittest_params;
6161
6162         int retval;
6163         unsigned plaintext_pad_len;
6164         unsigned plaintext_len;
6165         uint8_t *plaintext;
6166
6167         struct rte_cryptodev_info dev_info;
6168
6169         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6170         uint64_t feat_flags = dev_info.feature_flags;
6171
6172         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6173                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6174                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6175                 return TEST_SKIPPED;
6176         }
6177
6178         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6179                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6180                 printf("Device doesn't support RAW data-path APIs.\n");
6181                 return TEST_SKIPPED;
6182         }
6183
6184         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6185                 return TEST_SKIPPED;
6186
6187         /* Check if device supports ZUC EIA3 */
6188         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6189                         tdata->key.len, tdata->auth_iv.len,
6190                         tdata->digest.len) < 0)
6191                 return TEST_SKIPPED;
6192
6193         /* Create ZUC session */
6194         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6195                         tdata->key.data, tdata->key.len,
6196                         tdata->auth_iv.len, tdata->digest.len,
6197                         RTE_CRYPTO_AUTH_OP_GENERATE,
6198                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6199         if (retval != 0)
6200                 return retval;
6201
6202         /* alloc mbuf and set payload */
6203         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6204
6205         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6206         rte_pktmbuf_tailroom(ut_params->ibuf));
6207
6208         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6209         /* Append data which is padded to a multiple of */
6210         /* the algorithms block size */
6211         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6212         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6213                                 plaintext_pad_len);
6214         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6215
6216         /* Create ZUC operation */
6217         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6218                         tdata->auth_iv.data, tdata->auth_iv.len,
6219                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6220                         tdata->validAuthLenInBits.len,
6221                         0);
6222         if (retval < 0)
6223                 return retval;
6224
6225         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6226                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6227                                 ut_params->op, 0, 1, 1, 0);
6228         else
6229                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6230                                 ut_params->op);
6231         ut_params->obuf = ut_params->op->sym->m_src;
6232         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6233         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6234                         + plaintext_pad_len;
6235
6236         /* Validate obuf */
6237         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6238         ut_params->digest,
6239         tdata->digest.data,
6240         tdata->digest.len,
6241         "ZUC Generated auth tag not as expected");
6242
6243         return 0;
6244 }
6245
6246 static int
6247 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6248         uint8_t op_mode, uint8_t verify)
6249 {
6250         struct crypto_testsuite_params *ts_params = &testsuite_params;
6251         struct crypto_unittest_params *ut_params = &unittest_params;
6252
6253         int retval;
6254
6255         uint8_t *plaintext = NULL, *ciphertext = NULL;
6256         unsigned int plaintext_pad_len;
6257         unsigned int plaintext_len;
6258         unsigned int ciphertext_pad_len;
6259         unsigned int ciphertext_len;
6260
6261         struct rte_cryptodev_info dev_info;
6262
6263         /* Check if device supports ZUC EEA3 */
6264         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6265                         tdata->key.len, tdata->cipher_iv.len) < 0)
6266                 return TEST_SKIPPED;
6267
6268         /* Check if device supports ZUC EIA3 */
6269         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6270                         tdata->key.len, tdata->auth_iv.len,
6271                         tdata->digest.len) < 0)
6272                 return TEST_SKIPPED;
6273
6274         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6275
6276         uint64_t feat_flags = dev_info.feature_flags;
6277
6278         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6279                 printf("Device doesn't support digest encrypted.\n");
6280                 return TEST_SKIPPED;
6281         }
6282         if (op_mode == IN_PLACE) {
6283                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6284                         printf("Device doesn't support in-place scatter-gather "
6285                                         "in both input and output mbufs.\n");
6286                         return TEST_SKIPPED;
6287                 }
6288
6289                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6290                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6291                         printf("Device doesn't support RAW data-path APIs.\n");
6292                         return TEST_SKIPPED;
6293                 }
6294         } else {
6295                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6296                         return TEST_SKIPPED;
6297                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6298                         printf("Device doesn't support out-of-place scatter-gather "
6299                                         "in both input and output mbufs.\n");
6300                         return TEST_SKIPPED;
6301                 }
6302         }
6303
6304         /* Create ZUC session */
6305         retval = create_wireless_algo_auth_cipher_session(
6306                         ts_params->valid_devs[0],
6307                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6308                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6309                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6310                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6311                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6312                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6313                         tdata->key.data, tdata->key.len,
6314                         tdata->auth_iv.len, tdata->digest.len,
6315                         tdata->cipher_iv.len);
6316
6317         if (retval != 0)
6318                 return retval;
6319
6320         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6321         if (op_mode == OUT_OF_PLACE)
6322                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6323
6324         /* clear mbuf payload */
6325         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6326                 rte_pktmbuf_tailroom(ut_params->ibuf));
6327         if (op_mode == OUT_OF_PLACE)
6328                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6329                         rte_pktmbuf_tailroom(ut_params->obuf));
6330
6331         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6332         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6333         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6334         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6335
6336         if (verify) {
6337                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6338                                         ciphertext_pad_len);
6339                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6340                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6341                         ciphertext_len);
6342         } else {
6343                 /* make sure enough space to cover partial digest verify case */
6344                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6345                                         ciphertext_pad_len);
6346                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6347                 debug_hexdump(stdout, "plaintext:", plaintext,
6348                         plaintext_len);
6349         }
6350
6351         if (op_mode == OUT_OF_PLACE)
6352                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6353
6354         /* Create ZUC operation */
6355         retval = create_wireless_algo_auth_cipher_operation(
6356                 tdata->digest.data, tdata->digest.len,
6357                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6358                 tdata->auth_iv.data, tdata->auth_iv.len,
6359                 (tdata->digest.offset_bytes == 0 ?
6360                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6361                         : tdata->digest.offset_bytes),
6362                 tdata->validCipherLenInBits.len,
6363                 tdata->validCipherOffsetInBits.len,
6364                 tdata->validAuthLenInBits.len,
6365                 0,
6366                 op_mode, 0, verify);
6367
6368         if (retval < 0)
6369                 return retval;
6370
6371         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6372                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6373                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6374         else
6375                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6376                         ut_params->op);
6377
6378         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6379
6380         ut_params->obuf = (op_mode == IN_PLACE ?
6381                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6382
6383
6384         if (verify) {
6385                 if (ut_params->obuf)
6386                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6387                                                         uint8_t *);
6388                 else
6389                         plaintext = ciphertext;
6390
6391                 debug_hexdump(stdout, "plaintext:", plaintext,
6392                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6393                 debug_hexdump(stdout, "plaintext expected:",
6394                         tdata->plaintext.data,
6395                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6396         } else {
6397                 if (ut_params->obuf)
6398                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6399                                                         uint8_t *);
6400                 else
6401                         ciphertext = plaintext;
6402
6403                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6404                         ciphertext_len);
6405                 debug_hexdump(stdout, "ciphertext expected:",
6406                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6407
6408                 ut_params->digest = rte_pktmbuf_mtod(
6409                         ut_params->obuf, uint8_t *) +
6410                         (tdata->digest.offset_bytes == 0 ?
6411                         plaintext_pad_len : tdata->digest.offset_bytes);
6412
6413                 debug_hexdump(stdout, "digest:", ut_params->digest,
6414                         tdata->digest.len);
6415                 debug_hexdump(stdout, "digest expected:",
6416                         tdata->digest.data, tdata->digest.len);
6417         }
6418
6419         /* Validate obuf */
6420         if (verify) {
6421                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6422                         plaintext,
6423                         tdata->plaintext.data,
6424                         tdata->plaintext.len >> 3,
6425                         "ZUC Plaintext data not as expected");
6426         } else {
6427                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6428                         ciphertext,
6429                         tdata->ciphertext.data,
6430                         tdata->ciphertext.len >> 3,
6431                         "ZUC Ciphertext data not as expected");
6432
6433                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6434                         ut_params->digest,
6435                         tdata->digest.data,
6436                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6437                         "ZUC Generated auth tag not as expected");
6438         }
6439         return 0;
6440 }
6441
6442 static int
6443 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6444         uint8_t op_mode, uint8_t verify)
6445 {
6446         struct crypto_testsuite_params *ts_params = &testsuite_params;
6447         struct crypto_unittest_params *ut_params = &unittest_params;
6448
6449         int retval;
6450
6451         const uint8_t *plaintext = NULL;
6452         const uint8_t *ciphertext = NULL;
6453         const uint8_t *digest = NULL;
6454         unsigned int plaintext_pad_len;
6455         unsigned int plaintext_len;
6456         unsigned int ciphertext_pad_len;
6457         unsigned int ciphertext_len;
6458         uint8_t buffer[10000];
6459         uint8_t digest_buffer[10000];
6460
6461         struct rte_cryptodev_info dev_info;
6462
6463         /* Check if device supports ZUC EEA3 */
6464         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6465                         tdata->key.len, tdata->cipher_iv.len) < 0)
6466                 return TEST_SKIPPED;
6467
6468         /* Check if device supports ZUC EIA3 */
6469         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6470                         tdata->key.len, tdata->auth_iv.len,
6471                         tdata->digest.len) < 0)
6472                 return TEST_SKIPPED;
6473
6474         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6475
6476         uint64_t feat_flags = dev_info.feature_flags;
6477
6478         if (op_mode == IN_PLACE) {
6479                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6480                         printf("Device doesn't support in-place scatter-gather "
6481                                         "in both input and output mbufs.\n");
6482                         return TEST_SKIPPED;
6483                 }
6484
6485                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6486                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6487                         printf("Device doesn't support RAW data-path APIs.\n");
6488                         return TEST_SKIPPED;
6489                 }
6490         } else {
6491                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6492                         return TEST_SKIPPED;
6493                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6494                         printf("Device doesn't support out-of-place scatter-gather "
6495                                         "in both input and output mbufs.\n");
6496                         return TEST_SKIPPED;
6497                 }
6498                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6499                         printf("Device doesn't support digest encrypted.\n");
6500                         return TEST_SKIPPED;
6501                 }
6502         }
6503
6504         /* Create ZUC session */
6505         retval = create_wireless_algo_auth_cipher_session(
6506                         ts_params->valid_devs[0],
6507                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6508                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6509                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6510                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6511                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6512                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6513                         tdata->key.data, tdata->key.len,
6514                         tdata->auth_iv.len, tdata->digest.len,
6515                         tdata->cipher_iv.len);
6516
6517         if (retval != 0)
6518                 return retval;
6519
6520         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6521         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6522         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6523         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6524
6525         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6526                         plaintext_pad_len, 15, 0);
6527         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6528                         "Failed to allocate input buffer in mempool");
6529
6530         if (op_mode == OUT_OF_PLACE) {
6531                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6532                                 plaintext_pad_len, 15, 0);
6533                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6534                                 "Failed to allocate output buffer in mempool");
6535         }
6536
6537         if (verify) {
6538                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6539                         tdata->ciphertext.data);
6540                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6541                                         ciphertext_len, buffer);
6542                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6543                         ciphertext_len);
6544         } else {
6545                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6546                         tdata->plaintext.data);
6547                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6548                                         plaintext_len, buffer);
6549                 debug_hexdump(stdout, "plaintext:", plaintext,
6550                         plaintext_len);
6551         }
6552         memset(buffer, 0, sizeof(buffer));
6553
6554         /* Create ZUC operation */
6555         retval = create_wireless_algo_auth_cipher_operation(
6556                 tdata->digest.data, tdata->digest.len,
6557                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6558                 NULL, 0,
6559                 (tdata->digest.offset_bytes == 0 ?
6560                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6561                         : tdata->digest.offset_bytes),
6562                 tdata->validCipherLenInBits.len,
6563                 tdata->validCipherOffsetInBits.len,
6564                 tdata->validAuthLenInBits.len,
6565                 0,
6566                 op_mode, 1, verify);
6567
6568         if (retval < 0)
6569                 return retval;
6570
6571         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6572                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6573                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6574         else
6575                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6576                         ut_params->op);
6577
6578         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6579
6580         ut_params->obuf = (op_mode == IN_PLACE ?
6581                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6582
6583         if (verify) {
6584                 if (ut_params->obuf)
6585                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6586                                         plaintext_len, buffer);
6587                 else
6588                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6589                                         plaintext_len, buffer);
6590
6591                 debug_hexdump(stdout, "plaintext:", plaintext,
6592                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6593                 debug_hexdump(stdout, "plaintext expected:",
6594                         tdata->plaintext.data,
6595                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6596         } else {
6597                 if (ut_params->obuf)
6598                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6599                                         ciphertext_len, buffer);
6600                 else
6601                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6602                                         ciphertext_len, buffer);
6603
6604                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6605                         ciphertext_len);
6606                 debug_hexdump(stdout, "ciphertext expected:",
6607                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6608
6609                 if (ut_params->obuf)
6610                         digest = rte_pktmbuf_read(ut_params->obuf,
6611                                 (tdata->digest.offset_bytes == 0 ?
6612                                 plaintext_pad_len : tdata->digest.offset_bytes),
6613                                 tdata->digest.len, digest_buffer);
6614                 else
6615                         digest = rte_pktmbuf_read(ut_params->ibuf,
6616                                 (tdata->digest.offset_bytes == 0 ?
6617                                 plaintext_pad_len : tdata->digest.offset_bytes),
6618                                 tdata->digest.len, digest_buffer);
6619
6620                 debug_hexdump(stdout, "digest:", digest,
6621                         tdata->digest.len);
6622                 debug_hexdump(stdout, "digest expected:",
6623                         tdata->digest.data, tdata->digest.len);
6624         }
6625
6626         /* Validate obuf */
6627         if (verify) {
6628                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6629                         plaintext,
6630                         tdata->plaintext.data,
6631                         tdata->plaintext.len >> 3,
6632                         "ZUC Plaintext data not as expected");
6633         } else {
6634                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6635                         ciphertext,
6636                         tdata->ciphertext.data,
6637                         tdata->validDataLenInBits.len,
6638                         "ZUC Ciphertext data not as expected");
6639
6640                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6641                         digest,
6642                         tdata->digest.data,
6643                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6644                         "ZUC Generated auth tag not as expected");
6645         }
6646         return 0;
6647 }
6648
6649 static int
6650 test_kasumi_encryption_test_case_1(void)
6651 {
6652         return test_kasumi_encryption(&kasumi_test_case_1);
6653 }
6654
6655 static int
6656 test_kasumi_encryption_test_case_1_sgl(void)
6657 {
6658         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6659 }
6660
6661 static int
6662 test_kasumi_encryption_test_case_1_oop(void)
6663 {
6664         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6665 }
6666
6667 static int
6668 test_kasumi_encryption_test_case_1_oop_sgl(void)
6669 {
6670         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6671 }
6672
6673 static int
6674 test_kasumi_encryption_test_case_2(void)
6675 {
6676         return test_kasumi_encryption(&kasumi_test_case_2);
6677 }
6678
6679 static int
6680 test_kasumi_encryption_test_case_3(void)
6681 {
6682         return test_kasumi_encryption(&kasumi_test_case_3);
6683 }
6684
6685 static int
6686 test_kasumi_encryption_test_case_4(void)
6687 {
6688         return test_kasumi_encryption(&kasumi_test_case_4);
6689 }
6690
6691 static int
6692 test_kasumi_encryption_test_case_5(void)
6693 {
6694         return test_kasumi_encryption(&kasumi_test_case_5);
6695 }
6696
6697 static int
6698 test_kasumi_decryption_test_case_1(void)
6699 {
6700         return test_kasumi_decryption(&kasumi_test_case_1);
6701 }
6702
6703 static int
6704 test_kasumi_decryption_test_case_1_oop(void)
6705 {
6706         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6707 }
6708
6709 static int
6710 test_kasumi_decryption_test_case_2(void)
6711 {
6712         return test_kasumi_decryption(&kasumi_test_case_2);
6713 }
6714
6715 static int
6716 test_kasumi_decryption_test_case_3(void)
6717 {
6718         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6719         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6720                 return TEST_SKIPPED;
6721         return test_kasumi_decryption(&kasumi_test_case_3);
6722 }
6723
6724 static int
6725 test_kasumi_decryption_test_case_4(void)
6726 {
6727         return test_kasumi_decryption(&kasumi_test_case_4);
6728 }
6729
6730 static int
6731 test_kasumi_decryption_test_case_5(void)
6732 {
6733         return test_kasumi_decryption(&kasumi_test_case_5);
6734 }
6735 static int
6736 test_snow3g_encryption_test_case_1(void)
6737 {
6738         return test_snow3g_encryption(&snow3g_test_case_1);
6739 }
6740
6741 static int
6742 test_snow3g_encryption_test_case_1_oop(void)
6743 {
6744         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6745 }
6746
6747 static int
6748 test_snow3g_encryption_test_case_1_oop_sgl(void)
6749 {
6750         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6751 }
6752
6753
6754 static int
6755 test_snow3g_encryption_test_case_1_offset_oop(void)
6756 {
6757         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6758 }
6759
6760 static int
6761 test_snow3g_encryption_test_case_2(void)
6762 {
6763         return test_snow3g_encryption(&snow3g_test_case_2);
6764 }
6765
6766 static int
6767 test_snow3g_encryption_test_case_3(void)
6768 {
6769         return test_snow3g_encryption(&snow3g_test_case_3);
6770 }
6771
6772 static int
6773 test_snow3g_encryption_test_case_4(void)
6774 {
6775         return test_snow3g_encryption(&snow3g_test_case_4);
6776 }
6777
6778 static int
6779 test_snow3g_encryption_test_case_5(void)
6780 {
6781         return test_snow3g_encryption(&snow3g_test_case_5);
6782 }
6783
6784 static int
6785 test_snow3g_decryption_test_case_1(void)
6786 {
6787         return test_snow3g_decryption(&snow3g_test_case_1);
6788 }
6789
6790 static int
6791 test_snow3g_decryption_test_case_1_oop(void)
6792 {
6793         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6794 }
6795
6796 static int
6797 test_snow3g_decryption_test_case_2(void)
6798 {
6799         return test_snow3g_decryption(&snow3g_test_case_2);
6800 }
6801
6802 static int
6803 test_snow3g_decryption_test_case_3(void)
6804 {
6805         return test_snow3g_decryption(&snow3g_test_case_3);
6806 }
6807
6808 static int
6809 test_snow3g_decryption_test_case_4(void)
6810 {
6811         return test_snow3g_decryption(&snow3g_test_case_4);
6812 }
6813
6814 static int
6815 test_snow3g_decryption_test_case_5(void)
6816 {
6817         return test_snow3g_decryption(&snow3g_test_case_5);
6818 }
6819
6820 /*
6821  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6822  * Pattern digest from snow3g_test_data must be allocated as
6823  * 4 last bytes in plaintext.
6824  */
6825 static void
6826 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6827                 struct snow3g_hash_test_data *output)
6828 {
6829         if ((pattern != NULL) && (output != NULL)) {
6830                 output->key.len = pattern->key.len;
6831
6832                 memcpy(output->key.data,
6833                 pattern->key.data, pattern->key.len);
6834
6835                 output->auth_iv.len = pattern->auth_iv.len;
6836
6837                 memcpy(output->auth_iv.data,
6838                 pattern->auth_iv.data, pattern->auth_iv.len);
6839
6840                 output->plaintext.len = pattern->plaintext.len;
6841
6842                 memcpy(output->plaintext.data,
6843                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6844
6845                 output->digest.len = pattern->digest.len;
6846
6847                 memcpy(output->digest.data,
6848                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6849                 pattern->digest.len);
6850
6851                 output->validAuthLenInBits.len =
6852                 pattern->validAuthLenInBits.len;
6853         }
6854 }
6855
6856 /*
6857  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6858  */
6859 static int
6860 test_snow3g_decryption_with_digest_test_case_1(void)
6861 {
6862         struct snow3g_hash_test_data snow3g_hash_data;
6863         struct rte_cryptodev_info dev_info;
6864         struct crypto_testsuite_params *ts_params = &testsuite_params;
6865
6866         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6867         uint64_t feat_flags = dev_info.feature_flags;
6868
6869         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6870                 printf("Device doesn't support encrypted digest operations.\n");
6871                 return TEST_SKIPPED;
6872         }
6873
6874         /*
6875          * Function prepare data for hash verification test case.
6876          * Digest is allocated in 4 last bytes in plaintext, pattern.
6877          */
6878         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6879
6880         return test_snow3g_decryption(&snow3g_test_case_7) &
6881                         test_snow3g_authentication_verify(&snow3g_hash_data);
6882 }
6883
6884 static int
6885 test_snow3g_cipher_auth_test_case_1(void)
6886 {
6887         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6888 }
6889
6890 static int
6891 test_snow3g_auth_cipher_test_case_1(void)
6892 {
6893         return test_snow3g_auth_cipher(
6894                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6895 }
6896
6897 static int
6898 test_snow3g_auth_cipher_test_case_2(void)
6899 {
6900         return test_snow3g_auth_cipher(
6901                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6902 }
6903
6904 static int
6905 test_snow3g_auth_cipher_test_case_2_oop(void)
6906 {
6907         return test_snow3g_auth_cipher(
6908                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6909 }
6910
6911 static int
6912 test_snow3g_auth_cipher_part_digest_enc(void)
6913 {
6914         return test_snow3g_auth_cipher(
6915                 &snow3g_auth_cipher_partial_digest_encryption,
6916                         IN_PLACE, 0);
6917 }
6918
6919 static int
6920 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6921 {
6922         return test_snow3g_auth_cipher(
6923                 &snow3g_auth_cipher_partial_digest_encryption,
6924                         OUT_OF_PLACE, 0);
6925 }
6926
6927 static int
6928 test_snow3g_auth_cipher_test_case_3_sgl(void)
6929 {
6930         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6931         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6932                 return TEST_SKIPPED;
6933         return test_snow3g_auth_cipher_sgl(
6934                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6935 }
6936
6937 static int
6938 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6939 {
6940         return test_snow3g_auth_cipher_sgl(
6941                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6942 }
6943
6944 static int
6945 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6946 {
6947         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6948         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6949                 return TEST_SKIPPED;
6950         return test_snow3g_auth_cipher_sgl(
6951                 &snow3g_auth_cipher_partial_digest_encryption,
6952                         IN_PLACE, 0);
6953 }
6954
6955 static int
6956 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6957 {
6958         return test_snow3g_auth_cipher_sgl(
6959                 &snow3g_auth_cipher_partial_digest_encryption,
6960                         OUT_OF_PLACE, 0);
6961 }
6962
6963 static int
6964 test_snow3g_auth_cipher_verify_test_case_1(void)
6965 {
6966         return test_snow3g_auth_cipher(
6967                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6968 }
6969
6970 static int
6971 test_snow3g_auth_cipher_verify_test_case_2(void)
6972 {
6973         return test_snow3g_auth_cipher(
6974                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6975 }
6976
6977 static int
6978 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6979 {
6980         return test_snow3g_auth_cipher(
6981                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6982 }
6983
6984 static int
6985 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6986 {
6987         return test_snow3g_auth_cipher(
6988                 &snow3g_auth_cipher_partial_digest_encryption,
6989                         IN_PLACE, 1);
6990 }
6991
6992 static int
6993 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
6994 {
6995         return test_snow3g_auth_cipher(
6996                 &snow3g_auth_cipher_partial_digest_encryption,
6997                         OUT_OF_PLACE, 1);
6998 }
6999
7000 static int
7001 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7002 {
7003         return test_snow3g_auth_cipher_sgl(
7004                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7005 }
7006
7007 static int
7008 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7009 {
7010         return test_snow3g_auth_cipher_sgl(
7011                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7012 }
7013
7014 static int
7015 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7016 {
7017         return test_snow3g_auth_cipher_sgl(
7018                 &snow3g_auth_cipher_partial_digest_encryption,
7019                         IN_PLACE, 1);
7020 }
7021
7022 static int
7023 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7024 {
7025         return test_snow3g_auth_cipher_sgl(
7026                 &snow3g_auth_cipher_partial_digest_encryption,
7027                         OUT_OF_PLACE, 1);
7028 }
7029
7030 static int
7031 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7032 {
7033         return test_snow3g_auth_cipher(
7034                 &snow3g_test_case_7, IN_PLACE, 0);
7035 }
7036
7037 static int
7038 test_kasumi_auth_cipher_test_case_1(void)
7039 {
7040         return test_kasumi_auth_cipher(
7041                 &kasumi_test_case_3, IN_PLACE, 0);
7042 }
7043
7044 static int
7045 test_kasumi_auth_cipher_test_case_2(void)
7046 {
7047         return test_kasumi_auth_cipher(
7048                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7049 }
7050
7051 static int
7052 test_kasumi_auth_cipher_test_case_2_oop(void)
7053 {
7054         return test_kasumi_auth_cipher(
7055                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7056 }
7057
7058 static int
7059 test_kasumi_auth_cipher_test_case_2_sgl(void)
7060 {
7061         return test_kasumi_auth_cipher_sgl(
7062                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7063 }
7064
7065 static int
7066 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7067 {
7068         return test_kasumi_auth_cipher_sgl(
7069                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7070 }
7071
7072 static int
7073 test_kasumi_auth_cipher_verify_test_case_1(void)
7074 {
7075         return test_kasumi_auth_cipher(
7076                 &kasumi_test_case_3, IN_PLACE, 1);
7077 }
7078
7079 static int
7080 test_kasumi_auth_cipher_verify_test_case_2(void)
7081 {
7082         return test_kasumi_auth_cipher(
7083                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7084 }
7085
7086 static int
7087 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7088 {
7089         return test_kasumi_auth_cipher(
7090                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7091 }
7092
7093 static int
7094 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7095 {
7096         return test_kasumi_auth_cipher_sgl(
7097                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7098 }
7099
7100 static int
7101 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7102 {
7103         return test_kasumi_auth_cipher_sgl(
7104                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7105 }
7106
7107 static int
7108 test_kasumi_cipher_auth_test_case_1(void)
7109 {
7110         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7111 }
7112
7113 static int
7114 test_zuc_encryption_test_case_1(void)
7115 {
7116         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7117 }
7118
7119 static int
7120 test_zuc_encryption_test_case_2(void)
7121 {
7122         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7123 }
7124
7125 static int
7126 test_zuc_encryption_test_case_3(void)
7127 {
7128         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7129 }
7130
7131 static int
7132 test_zuc_encryption_test_case_4(void)
7133 {
7134         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7135 }
7136
7137 static int
7138 test_zuc_encryption_test_case_5(void)
7139 {
7140         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7141 }
7142
7143 static int
7144 test_zuc_encryption_test_case_6_sgl(void)
7145 {
7146         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7147 }
7148
7149 static int
7150 test_zuc_hash_generate_test_case_1(void)
7151 {
7152         return test_zuc_authentication(&zuc_test_case_auth_1b);
7153 }
7154
7155 static int
7156 test_zuc_hash_generate_test_case_2(void)
7157 {
7158         return test_zuc_authentication(&zuc_test_case_auth_90b);
7159 }
7160
7161 static int
7162 test_zuc_hash_generate_test_case_3(void)
7163 {
7164         return test_zuc_authentication(&zuc_test_case_auth_577b);
7165 }
7166
7167 static int
7168 test_zuc_hash_generate_test_case_4(void)
7169 {
7170         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7171 }
7172
7173 static int
7174 test_zuc_hash_generate_test_case_5(void)
7175 {
7176         return test_zuc_authentication(&zuc_test_auth_5670b);
7177 }
7178
7179 static int
7180 test_zuc_hash_generate_test_case_6(void)
7181 {
7182         return test_zuc_authentication(&zuc_test_case_auth_128b);
7183 }
7184
7185 static int
7186 test_zuc_hash_generate_test_case_7(void)
7187 {
7188         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7189 }
7190
7191 static int
7192 test_zuc_hash_generate_test_case_8(void)
7193 {
7194         return test_zuc_authentication(&zuc_test_case_auth_584b);
7195 }
7196
7197 static int
7198 test_zuc_hash_generate_test_case_9(void)
7199 {
7200         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7201 }
7202
7203 static int
7204 test_zuc_hash_generate_test_case_10(void)
7205 {
7206         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7207 }
7208
7209 static int
7210 test_zuc_hash_generate_test_case_11(void)
7211 {
7212         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7213 }
7214
7215 static int
7216 test_zuc_cipher_auth_test_case_1(void)
7217 {
7218         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7219 }
7220
7221 static int
7222 test_zuc_cipher_auth_test_case_2(void)
7223 {
7224         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7225 }
7226
7227 static int
7228 test_zuc_auth_cipher_test_case_1(void)
7229 {
7230         return test_zuc_auth_cipher(
7231                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7232 }
7233
7234 static int
7235 test_zuc_auth_cipher_test_case_1_oop(void)
7236 {
7237         return test_zuc_auth_cipher(
7238                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7239 }
7240
7241 static int
7242 test_zuc_auth_cipher_test_case_1_sgl(void)
7243 {
7244         return test_zuc_auth_cipher_sgl(
7245                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7246 }
7247
7248 static int
7249 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7250 {
7251         return test_zuc_auth_cipher_sgl(
7252                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7253 }
7254
7255 static int
7256 test_zuc_auth_cipher_verify_test_case_1(void)
7257 {
7258         return test_zuc_auth_cipher(
7259                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7260 }
7261
7262 static int
7263 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7264 {
7265         return test_zuc_auth_cipher(
7266                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7267 }
7268
7269 static int
7270 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7271 {
7272         return test_zuc_auth_cipher_sgl(
7273                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7274 }
7275
7276 static int
7277 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7278 {
7279         return test_zuc_auth_cipher_sgl(
7280                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7281 }
7282
7283 static int
7284 test_zuc256_encryption_test_case_1(void)
7285 {
7286         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7287 }
7288
7289 static int
7290 test_zuc256_encryption_test_case_2(void)
7291 {
7292         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7293 }
7294
7295 static int
7296 test_zuc256_authentication_test_case_1(void)
7297 {
7298         return test_zuc_authentication(&zuc256_test_case_auth_1);
7299 }
7300
7301 static int
7302 test_zuc256_authentication_test_case_2(void)
7303 {
7304         return test_zuc_authentication(&zuc256_test_case_auth_2);
7305 }
7306
7307 static int
7308 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7309 {
7310         uint8_t dev_id = testsuite_params.valid_devs[0];
7311
7312         struct rte_cryptodev_sym_capability_idx cap_idx;
7313
7314         /* Check if device supports particular cipher algorithm */
7315         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7316         cap_idx.algo.cipher = tdata->cipher_algo;
7317         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7318                 return TEST_SKIPPED;
7319
7320         /* Check if device supports particular hash algorithm */
7321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7322         cap_idx.algo.auth = tdata->auth_algo;
7323         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7324                 return TEST_SKIPPED;
7325
7326         return 0;
7327 }
7328
7329 static int
7330 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7331         uint8_t op_mode, uint8_t verify)
7332 {
7333         struct crypto_testsuite_params *ts_params = &testsuite_params;
7334         struct crypto_unittest_params *ut_params = &unittest_params;
7335
7336         int retval;
7337
7338         uint8_t *plaintext = NULL, *ciphertext = NULL;
7339         unsigned int plaintext_pad_len;
7340         unsigned int plaintext_len;
7341         unsigned int ciphertext_pad_len;
7342         unsigned int ciphertext_len;
7343
7344         struct rte_cryptodev_info dev_info;
7345         struct rte_crypto_op *op;
7346
7347         /* Check if device supports particular algorithms separately */
7348         if (test_mixed_check_if_unsupported(tdata))
7349                 return TEST_SKIPPED;
7350         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7351                 return TEST_SKIPPED;
7352
7353         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7354
7355         uint64_t feat_flags = dev_info.feature_flags;
7356
7357         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7358                 printf("Device doesn't support digest encrypted.\n");
7359                 return TEST_SKIPPED;
7360         }
7361
7362         /* Create the session */
7363         if (verify)
7364                 retval = create_wireless_algo_cipher_auth_session(
7365                                 ts_params->valid_devs[0],
7366                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7367                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7368                                 tdata->auth_algo,
7369                                 tdata->cipher_algo,
7370                                 tdata->auth_key.data, tdata->auth_key.len,
7371                                 tdata->auth_iv.len, tdata->digest_enc.len,
7372                                 tdata->cipher_iv.len);
7373         else
7374                 retval = create_wireless_algo_auth_cipher_session(
7375                                 ts_params->valid_devs[0],
7376                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7377                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7378                                 tdata->auth_algo,
7379                                 tdata->cipher_algo,
7380                                 tdata->auth_key.data, tdata->auth_key.len,
7381                                 tdata->auth_iv.len, tdata->digest_enc.len,
7382                                 tdata->cipher_iv.len);
7383         if (retval != 0)
7384                 return retval;
7385
7386         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7387         if (op_mode == OUT_OF_PLACE)
7388                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7389
7390         /* clear mbuf payload */
7391         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7392                 rte_pktmbuf_tailroom(ut_params->ibuf));
7393         if (op_mode == OUT_OF_PLACE) {
7394
7395                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7396                                 rte_pktmbuf_tailroom(ut_params->obuf));
7397         }
7398
7399         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7400         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7401         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7402         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7403
7404         if (verify) {
7405                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7406                                 ciphertext_pad_len);
7407                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7408                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7409                                 ciphertext_len);
7410         } else {
7411                 /* make sure enough space to cover partial digest verify case */
7412                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7413                                 ciphertext_pad_len);
7414                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7415                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7416         }
7417
7418         if (op_mode == OUT_OF_PLACE)
7419                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7420
7421         /* Create the operation */
7422         retval = create_wireless_algo_auth_cipher_operation(
7423                         tdata->digest_enc.data, tdata->digest_enc.len,
7424                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7425                         tdata->auth_iv.data, tdata->auth_iv.len,
7426                         (tdata->digest_enc.offset == 0 ?
7427                                 plaintext_pad_len
7428                                 : tdata->digest_enc.offset),
7429                         tdata->validCipherLen.len_bits,
7430                         tdata->cipher.offset_bits,
7431                         tdata->validAuthLen.len_bits,
7432                         tdata->auth.offset_bits,
7433                         op_mode, 0, verify);
7434
7435         if (retval < 0)
7436                 return retval;
7437
7438         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7439
7440         /* Check if the op failed because the device doesn't */
7441         /* support this particular combination of algorithms */
7442         if (op == NULL && ut_params->op->status ==
7443                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7444                 printf("Device doesn't support this mixed combination. "
7445                                 "Test Skipped.\n");
7446                 return TEST_SKIPPED;
7447         }
7448         ut_params->op = op;
7449
7450         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7451
7452         ut_params->obuf = (op_mode == IN_PLACE ?
7453                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7454
7455         if (verify) {
7456                 if (ut_params->obuf)
7457                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7458                                                         uint8_t *);
7459                 else
7460                         plaintext = ciphertext +
7461                                         (tdata->cipher.offset_bits >> 3);
7462
7463                 debug_hexdump(stdout, "plaintext:", plaintext,
7464                                 tdata->plaintext.len_bits >> 3);
7465                 debug_hexdump(stdout, "plaintext expected:",
7466                                 tdata->plaintext.data,
7467                                 tdata->plaintext.len_bits >> 3);
7468         } else {
7469                 if (ut_params->obuf)
7470                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7471                                         uint8_t *);
7472                 else
7473                         ciphertext = plaintext;
7474
7475                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7476                                 ciphertext_len);
7477                 debug_hexdump(stdout, "ciphertext expected:",
7478                                 tdata->ciphertext.data,
7479                                 tdata->ciphertext.len_bits >> 3);
7480
7481                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7482                                 + (tdata->digest_enc.offset == 0 ?
7483                 plaintext_pad_len : tdata->digest_enc.offset);
7484
7485                 debug_hexdump(stdout, "digest:", ut_params->digest,
7486                                 tdata->digest_enc.len);
7487                 debug_hexdump(stdout, "digest expected:",
7488                                 tdata->digest_enc.data,
7489                                 tdata->digest_enc.len);
7490         }
7491
7492         if (!verify) {
7493                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7494                                 ut_params->digest,
7495                                 tdata->digest_enc.data,
7496                                 tdata->digest_enc.len,
7497                                 "Generated auth tag not as expected");
7498         }
7499
7500         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7501                 if (verify) {
7502                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7503                                         plaintext,
7504                                         tdata->plaintext.data,
7505                                         tdata->plaintext.len_bits >> 3,
7506                                         "Plaintext data not as expected");
7507                 } else {
7508                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7509                                         ciphertext,
7510                                         tdata->ciphertext.data,
7511                                         tdata->validDataLen.len_bits,
7512                                         "Ciphertext data not as expected");
7513                 }
7514         }
7515
7516         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7517                         "crypto op processing failed");
7518
7519         return 0;
7520 }
7521
7522 static int
7523 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7524         uint8_t op_mode, uint8_t verify)
7525 {
7526         struct crypto_testsuite_params *ts_params = &testsuite_params;
7527         struct crypto_unittest_params *ut_params = &unittest_params;
7528
7529         int retval;
7530
7531         const uint8_t *plaintext = NULL;
7532         const uint8_t *ciphertext = NULL;
7533         const uint8_t *digest = NULL;
7534         unsigned int plaintext_pad_len;
7535         unsigned int plaintext_len;
7536         unsigned int ciphertext_pad_len;
7537         unsigned int ciphertext_len;
7538         uint8_t buffer[10000];
7539         uint8_t digest_buffer[10000];
7540
7541         struct rte_cryptodev_info dev_info;
7542         struct rte_crypto_op *op;
7543
7544         /* Check if device supports particular algorithms */
7545         if (test_mixed_check_if_unsupported(tdata))
7546                 return TEST_SKIPPED;
7547         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7548                 return TEST_SKIPPED;
7549
7550         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7551
7552         uint64_t feat_flags = dev_info.feature_flags;
7553
7554         if (op_mode == IN_PLACE) {
7555                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7556                         printf("Device doesn't support in-place scatter-gather "
7557                                         "in both input and output mbufs.\n");
7558                         return TEST_SKIPPED;
7559                 }
7560         } else {
7561                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7562                         printf("Device doesn't support out-of-place scatter-gather "
7563                                         "in both input and output mbufs.\n");
7564                         return TEST_SKIPPED;
7565                 }
7566                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7567                         printf("Device doesn't support digest encrypted.\n");
7568                         return TEST_SKIPPED;
7569                 }
7570         }
7571
7572         /* Create the session */
7573         if (verify)
7574                 retval = create_wireless_algo_cipher_auth_session(
7575                                 ts_params->valid_devs[0],
7576                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7577                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7578                                 tdata->auth_algo,
7579                                 tdata->cipher_algo,
7580                                 tdata->auth_key.data, tdata->auth_key.len,
7581                                 tdata->auth_iv.len, tdata->digest_enc.len,
7582                                 tdata->cipher_iv.len);
7583         else
7584                 retval = create_wireless_algo_auth_cipher_session(
7585                                 ts_params->valid_devs[0],
7586                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7587                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7588                                 tdata->auth_algo,
7589                                 tdata->cipher_algo,
7590                                 tdata->auth_key.data, tdata->auth_key.len,
7591                                 tdata->auth_iv.len, tdata->digest_enc.len,
7592                                 tdata->cipher_iv.len);
7593         if (retval != 0)
7594                 return retval;
7595
7596         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7597         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7598         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7599         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7600
7601         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7602                         ciphertext_pad_len, 15, 0);
7603         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7604                         "Failed to allocate input buffer in mempool");
7605
7606         if (op_mode == OUT_OF_PLACE) {
7607                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7608                                 plaintext_pad_len, 15, 0);
7609                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7610                                 "Failed to allocate output buffer in mempool");
7611         }
7612
7613         if (verify) {
7614                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7615                         tdata->ciphertext.data);
7616                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7617                                         ciphertext_len, buffer);
7618                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7619                         ciphertext_len);
7620         } else {
7621                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7622                         tdata->plaintext.data);
7623                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7624                                         plaintext_len, buffer);
7625                 debug_hexdump(stdout, "plaintext:", plaintext,
7626                         plaintext_len);
7627         }
7628         memset(buffer, 0, sizeof(buffer));
7629
7630         /* Create the operation */
7631         retval = create_wireless_algo_auth_cipher_operation(
7632                         tdata->digest_enc.data, tdata->digest_enc.len,
7633                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7634                         tdata->auth_iv.data, tdata->auth_iv.len,
7635                         (tdata->digest_enc.offset == 0 ?
7636                                 plaintext_pad_len
7637                                 : tdata->digest_enc.offset),
7638                         tdata->validCipherLen.len_bits,
7639                         tdata->cipher.offset_bits,
7640                         tdata->validAuthLen.len_bits,
7641                         tdata->auth.offset_bits,
7642                         op_mode, 1, verify);
7643
7644         if (retval < 0)
7645                 return retval;
7646
7647         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7648
7649         /* Check if the op failed because the device doesn't */
7650         /* support this particular combination of algorithms */
7651         if (op == NULL && ut_params->op->status ==
7652                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7653                 printf("Device doesn't support this mixed combination. "
7654                                 "Test Skipped.\n");
7655                 return TEST_SKIPPED;
7656         }
7657         ut_params->op = op;
7658
7659         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7660
7661         ut_params->obuf = (op_mode == IN_PLACE ?
7662                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7663
7664         if (verify) {
7665                 if (ut_params->obuf)
7666                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7667                                         plaintext_len, buffer);
7668                 else
7669                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7670                                         plaintext_len, buffer);
7671
7672                 debug_hexdump(stdout, "plaintext:", plaintext,
7673                                 (tdata->plaintext.len_bits >> 3) -
7674                                 tdata->digest_enc.len);
7675                 debug_hexdump(stdout, "plaintext expected:",
7676                                 tdata->plaintext.data,
7677                                 (tdata->plaintext.len_bits >> 3) -
7678                                 tdata->digest_enc.len);
7679         } else {
7680                 if (ut_params->obuf)
7681                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7682                                         ciphertext_len, buffer);
7683                 else
7684                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7685                                         ciphertext_len, buffer);
7686
7687                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7688                         ciphertext_len);
7689                 debug_hexdump(stdout, "ciphertext expected:",
7690                         tdata->ciphertext.data,
7691                         tdata->ciphertext.len_bits >> 3);
7692
7693                 if (ut_params->obuf)
7694                         digest = rte_pktmbuf_read(ut_params->obuf,
7695                                         (tdata->digest_enc.offset == 0 ?
7696                                                 plaintext_pad_len :
7697                                                 tdata->digest_enc.offset),
7698                                         tdata->digest_enc.len, digest_buffer);
7699                 else
7700                         digest = rte_pktmbuf_read(ut_params->ibuf,
7701                                         (tdata->digest_enc.offset == 0 ?
7702                                                 plaintext_pad_len :
7703                                                 tdata->digest_enc.offset),
7704                                         tdata->digest_enc.len, digest_buffer);
7705
7706                 debug_hexdump(stdout, "digest:", digest,
7707                                 tdata->digest_enc.len);
7708                 debug_hexdump(stdout, "digest expected:",
7709                                 tdata->digest_enc.data, tdata->digest_enc.len);
7710         }
7711
7712         if (!verify) {
7713                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7714                                 digest,
7715                                 tdata->digest_enc.data,
7716                                 tdata->digest_enc.len,
7717                                 "Generated auth tag not as expected");
7718         }
7719
7720         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7721                 if (verify) {
7722                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7723                                         plaintext,
7724                                         tdata->plaintext.data,
7725                                         tdata->plaintext.len_bits >> 3,
7726                                         "Plaintext data not as expected");
7727                 } else {
7728                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7729                                         ciphertext,
7730                                         tdata->ciphertext.data,
7731                                         tdata->validDataLen.len_bits,
7732                                         "Ciphertext data not as expected");
7733                 }
7734         }
7735
7736         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7737                         "crypto op processing failed");
7738
7739         return 0;
7740 }
7741
7742 /** AUTH AES CMAC + CIPHER AES CTR */
7743
7744 static int
7745 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7746 {
7747         return test_mixed_auth_cipher(
7748                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7749 }
7750
7751 static int
7752 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7753 {
7754         return test_mixed_auth_cipher(
7755                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7756 }
7757
7758 static int
7759 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7760 {
7761         return test_mixed_auth_cipher_sgl(
7762                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7763 }
7764
7765 static int
7766 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7767 {
7768         return test_mixed_auth_cipher_sgl(
7769                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7770 }
7771
7772 static int
7773 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7774 {
7775         return test_mixed_auth_cipher(
7776                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7777 }
7778
7779 static int
7780 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7781 {
7782         return test_mixed_auth_cipher(
7783                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7784 }
7785
7786 static int
7787 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7788 {
7789         return test_mixed_auth_cipher_sgl(
7790                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7791 }
7792
7793 static int
7794 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7795 {
7796         return test_mixed_auth_cipher_sgl(
7797                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7798 }
7799
7800 /** MIXED AUTH + CIPHER */
7801
7802 static int
7803 test_auth_zuc_cipher_snow_test_case_1(void)
7804 {
7805         return test_mixed_auth_cipher(
7806                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7807 }
7808
7809 static int
7810 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7811 {
7812         return test_mixed_auth_cipher(
7813                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7814 }
7815
7816 static int
7817 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7818 {
7819         return test_mixed_auth_cipher(
7820                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7821 }
7822
7823 static int
7824 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7825 {
7826         return test_mixed_auth_cipher(
7827                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7828 }
7829
7830 static int
7831 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7832 {
7833         return test_mixed_auth_cipher(
7834                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7835 }
7836
7837 static int
7838 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7839 {
7840         return test_mixed_auth_cipher(
7841                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7842 }
7843
7844 static int
7845 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7846 {
7847         return test_mixed_auth_cipher(
7848                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7849 }
7850
7851 static int
7852 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7853 {
7854         return test_mixed_auth_cipher(
7855                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7856 }
7857
7858 static int
7859 test_auth_snow_cipher_zuc_test_case_1(void)
7860 {
7861         return test_mixed_auth_cipher(
7862                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7863 }
7864
7865 static int
7866 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7867 {
7868         return test_mixed_auth_cipher(
7869                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7870 }
7871
7872 static int
7873 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7874 {
7875         return test_mixed_auth_cipher(
7876                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7877 }
7878
7879 static int
7880 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7881 {
7882         return test_mixed_auth_cipher(
7883                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7884 }
7885
7886 static int
7887 test_auth_null_cipher_snow_test_case_1(void)
7888 {
7889         return test_mixed_auth_cipher(
7890                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7891 }
7892
7893 static int
7894 test_verify_auth_null_cipher_snow_test_case_1(void)
7895 {
7896         return test_mixed_auth_cipher(
7897                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7898 }
7899
7900 static int
7901 test_auth_null_cipher_zuc_test_case_1(void)
7902 {
7903         return test_mixed_auth_cipher(
7904                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7905 }
7906
7907 static int
7908 test_verify_auth_null_cipher_zuc_test_case_1(void)
7909 {
7910         return test_mixed_auth_cipher(
7911                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7912 }
7913
7914 static int
7915 test_auth_snow_cipher_null_test_case_1(void)
7916 {
7917         return test_mixed_auth_cipher(
7918                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7919 }
7920
7921 static int
7922 test_verify_auth_snow_cipher_null_test_case_1(void)
7923 {
7924         return test_mixed_auth_cipher(
7925                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7926 }
7927
7928 static int
7929 test_auth_zuc_cipher_null_test_case_1(void)
7930 {
7931         return test_mixed_auth_cipher(
7932                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7933 }
7934
7935 static int
7936 test_verify_auth_zuc_cipher_null_test_case_1(void)
7937 {
7938         return test_mixed_auth_cipher(
7939                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7940 }
7941
7942 static int
7943 test_auth_null_cipher_aes_ctr_test_case_1(void)
7944 {
7945         return test_mixed_auth_cipher(
7946                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7947 }
7948
7949 static int
7950 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7951 {
7952         return test_mixed_auth_cipher(
7953                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7954 }
7955
7956 static int
7957 test_auth_aes_cmac_cipher_null_test_case_1(void)
7958 {
7959         return test_mixed_auth_cipher(
7960                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7961 }
7962
7963 static int
7964 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7965 {
7966         return test_mixed_auth_cipher(
7967                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7968 }
7969
7970 /* ***** AEAD algorithm Tests ***** */
7971
7972 static int
7973 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7974                 enum rte_crypto_aead_operation op,
7975                 const uint8_t *key, const uint8_t key_len,
7976                 const uint16_t aad_len, const uint8_t auth_len,
7977                 uint8_t iv_len)
7978 {
7979         uint8_t aead_key[key_len];
7980         int status;
7981
7982         struct crypto_testsuite_params *ts_params = &testsuite_params;
7983         struct crypto_unittest_params *ut_params = &unittest_params;
7984
7985         memcpy(aead_key, key, key_len);
7986
7987         /* Setup AEAD Parameters */
7988         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7989         ut_params->aead_xform.next = NULL;
7990         ut_params->aead_xform.aead.algo = algo;
7991         ut_params->aead_xform.aead.op = op;
7992         ut_params->aead_xform.aead.key.data = aead_key;
7993         ut_params->aead_xform.aead.key.length = key_len;
7994         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
7995         ut_params->aead_xform.aead.iv.length = iv_len;
7996         ut_params->aead_xform.aead.digest_length = auth_len;
7997         ut_params->aead_xform.aead.aad_length = aad_len;
7998
7999         debug_hexdump(stdout, "key:", key, key_len);
8000
8001         /* Create Crypto session*/
8002         ut_params->sess = rte_cryptodev_sym_session_create(
8003                         ts_params->session_mpool);
8004         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8005
8006         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8007                         &ut_params->aead_xform,
8008                         ts_params->session_priv_mpool);
8009
8010         return status;
8011 }
8012
8013 static int
8014 create_aead_xform(struct rte_crypto_op *op,
8015                 enum rte_crypto_aead_algorithm algo,
8016                 enum rte_crypto_aead_operation aead_op,
8017                 uint8_t *key, const uint8_t key_len,
8018                 const uint8_t aad_len, const uint8_t auth_len,
8019                 uint8_t iv_len)
8020 {
8021         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8022                         "failed to allocate space for crypto transform");
8023
8024         struct rte_crypto_sym_op *sym_op = op->sym;
8025
8026         /* Setup AEAD Parameters */
8027         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8028         sym_op->xform->next = NULL;
8029         sym_op->xform->aead.algo = algo;
8030         sym_op->xform->aead.op = aead_op;
8031         sym_op->xform->aead.key.data = key;
8032         sym_op->xform->aead.key.length = key_len;
8033         sym_op->xform->aead.iv.offset = IV_OFFSET;
8034         sym_op->xform->aead.iv.length = iv_len;
8035         sym_op->xform->aead.digest_length = auth_len;
8036         sym_op->xform->aead.aad_length = aad_len;
8037
8038         debug_hexdump(stdout, "key:", key, key_len);
8039
8040         return 0;
8041 }
8042
8043 static int
8044 create_aead_operation(enum rte_crypto_aead_operation op,
8045                 const struct aead_test_data *tdata)
8046 {
8047         struct crypto_testsuite_params *ts_params = &testsuite_params;
8048         struct crypto_unittest_params *ut_params = &unittest_params;
8049
8050         uint8_t *plaintext, *ciphertext;
8051         unsigned int aad_pad_len, plaintext_pad_len;
8052
8053         /* Generate Crypto op data structure */
8054         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8055                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8056         TEST_ASSERT_NOT_NULL(ut_params->op,
8057                         "Failed to allocate symmetric crypto operation struct");
8058
8059         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8060
8061         /* Append aad data */
8062         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8063                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8064                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8065                                 aad_pad_len);
8066                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8067                                 "no room to append aad");
8068
8069                 sym_op->aead.aad.phys_addr =
8070                                 rte_pktmbuf_iova(ut_params->ibuf);
8071                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8072                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8073                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8074                         tdata->aad.len);
8075
8076                 /* Append IV at the end of the crypto operation*/
8077                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8078                                 uint8_t *, IV_OFFSET);
8079
8080                 /* Copy IV 1 byte after the IV pointer, according to the API */
8081                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8082                 debug_hexdump(stdout, "iv:", iv_ptr,
8083                         tdata->iv.len);
8084         } else {
8085                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8086                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8087                                 aad_pad_len);
8088                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8089                                 "no room to append aad");
8090
8091                 sym_op->aead.aad.phys_addr =
8092                                 rte_pktmbuf_iova(ut_params->ibuf);
8093                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8094                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8095                         tdata->aad.len);
8096
8097                 /* Append IV at the end of the crypto operation*/
8098                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8099                                 uint8_t *, IV_OFFSET);
8100
8101                 if (tdata->iv.len == 0) {
8102                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8103                         debug_hexdump(stdout, "iv:", iv_ptr,
8104                                 AES_GCM_J0_LENGTH);
8105                 } else {
8106                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8107                         debug_hexdump(stdout, "iv:", iv_ptr,
8108                                 tdata->iv.len);
8109                 }
8110         }
8111
8112         /* Append plaintext/ciphertext */
8113         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8114                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8115                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8116                                 plaintext_pad_len);
8117                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8118
8119                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8120                 debug_hexdump(stdout, "plaintext:", plaintext,
8121                                 tdata->plaintext.len);
8122
8123                 if (ut_params->obuf) {
8124                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8125                                         ut_params->obuf,
8126                                         plaintext_pad_len + aad_pad_len);
8127                         TEST_ASSERT_NOT_NULL(ciphertext,
8128                                         "no room to append ciphertext");
8129
8130                         memset(ciphertext + aad_pad_len, 0,
8131                                         tdata->ciphertext.len);
8132                 }
8133         } else {
8134                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8135                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8136                                 plaintext_pad_len);
8137                 TEST_ASSERT_NOT_NULL(ciphertext,
8138                                 "no room to append ciphertext");
8139
8140                 memcpy(ciphertext, tdata->ciphertext.data,
8141                                 tdata->ciphertext.len);
8142                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8143                                 tdata->ciphertext.len);
8144
8145                 if (ut_params->obuf) {
8146                         plaintext = (uint8_t *)rte_pktmbuf_append(
8147                                         ut_params->obuf,
8148                                         plaintext_pad_len + aad_pad_len);
8149                         TEST_ASSERT_NOT_NULL(plaintext,
8150                                         "no room to append plaintext");
8151
8152                         memset(plaintext + aad_pad_len, 0,
8153                                         tdata->plaintext.len);
8154                 }
8155         }
8156
8157         /* Append digest data */
8158         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8159                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8160                                 ut_params->obuf ? ut_params->obuf :
8161                                                 ut_params->ibuf,
8162                                                 tdata->auth_tag.len);
8163                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8164                                 "no room to append digest");
8165                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8166                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8167                                 ut_params->obuf ? ut_params->obuf :
8168                                                 ut_params->ibuf,
8169                                                 plaintext_pad_len +
8170                                                 aad_pad_len);
8171         } else {
8172                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8173                                 ut_params->ibuf, tdata->auth_tag.len);
8174                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8175                                 "no room to append digest");
8176                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8177                                 ut_params->ibuf,
8178                                 plaintext_pad_len + aad_pad_len);
8179
8180                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8181                         tdata->auth_tag.len);
8182                 debug_hexdump(stdout, "digest:",
8183                         sym_op->aead.digest.data,
8184                         tdata->auth_tag.len);
8185         }
8186
8187         sym_op->aead.data.length = tdata->plaintext.len;
8188         sym_op->aead.data.offset = aad_pad_len;
8189
8190         return 0;
8191 }
8192
8193 static int
8194 test_authenticated_encryption(const struct aead_test_data *tdata)
8195 {
8196         struct crypto_testsuite_params *ts_params = &testsuite_params;
8197         struct crypto_unittest_params *ut_params = &unittest_params;
8198
8199         int retval;
8200         uint8_t *ciphertext, *auth_tag;
8201         uint16_t plaintext_pad_len;
8202         uint32_t i;
8203         struct rte_cryptodev_info dev_info;
8204
8205         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8206         uint64_t feat_flags = dev_info.feature_flags;
8207
8208         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8209                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8210                 printf("Device doesn't support RAW data-path APIs.\n");
8211                 return TEST_SKIPPED;
8212         }
8213
8214         /* Verify the capabilities */
8215         struct rte_cryptodev_sym_capability_idx cap_idx;
8216         const struct rte_cryptodev_symmetric_capability *capability;
8217         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8218         cap_idx.algo.aead = tdata->algo;
8219         capability = rte_cryptodev_sym_capability_get(
8220                         ts_params->valid_devs[0], &cap_idx);
8221         if (capability == NULL)
8222                 return TEST_SKIPPED;
8223         if (rte_cryptodev_sym_capability_check_aead(
8224                         capability, tdata->key.len, tdata->auth_tag.len,
8225                         tdata->aad.len, tdata->iv.len))
8226                 return TEST_SKIPPED;
8227
8228         /* Create AEAD session */
8229         retval = create_aead_session(ts_params->valid_devs[0],
8230                         tdata->algo,
8231                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8232                         tdata->key.data, tdata->key.len,
8233                         tdata->aad.len, tdata->auth_tag.len,
8234                         tdata->iv.len);
8235         if (retval < 0)
8236                 return retval;
8237
8238         if (tdata->aad.len > MBUF_SIZE) {
8239                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8240                 /* Populate full size of add data */
8241                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8242                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8243         } else
8244                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8245
8246         /* clear mbuf payload */
8247         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8248                         rte_pktmbuf_tailroom(ut_params->ibuf));
8249
8250         /* Create AEAD operation */
8251         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8252         if (retval < 0)
8253                 return retval;
8254
8255         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8256
8257         ut_params->op->sym->m_src = ut_params->ibuf;
8258
8259         /* Process crypto operation */
8260         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8261                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8262         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8263                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8264                                 ut_params->op, 0, 0, 0, 0);
8265         else
8266                 TEST_ASSERT_NOT_NULL(
8267                         process_crypto_request(ts_params->valid_devs[0],
8268                         ut_params->op), "failed to process sym crypto op");
8269
8270         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8271                         "crypto op processing failed");
8272
8273         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8274
8275         if (ut_params->op->sym->m_dst) {
8276                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8277                                 uint8_t *);
8278                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8279                                 uint8_t *, plaintext_pad_len);
8280         } else {
8281                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8282                                 uint8_t *,
8283                                 ut_params->op->sym->cipher.data.offset);
8284                 auth_tag = ciphertext + plaintext_pad_len;
8285         }
8286
8287         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8288         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8289
8290         /* Validate obuf */
8291         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8292                         ciphertext,
8293                         tdata->ciphertext.data,
8294                         tdata->ciphertext.len,
8295                         "Ciphertext data not as expected");
8296
8297         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8298                         auth_tag,
8299                         tdata->auth_tag.data,
8300                         tdata->auth_tag.len,
8301                         "Generated auth tag not as expected");
8302
8303         return 0;
8304
8305 }
8306
8307 #ifdef RTE_LIB_SECURITY
8308 static int
8309 security_proto_supported(enum rte_security_session_action_type action,
8310         enum rte_security_session_protocol proto)
8311 {
8312         struct crypto_testsuite_params *ts_params = &testsuite_params;
8313
8314         const struct rte_security_capability *capabilities;
8315         const struct rte_security_capability *capability;
8316         uint16_t i = 0;
8317
8318         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8319                                 rte_cryptodev_get_sec_ctx(
8320                                 ts_params->valid_devs[0]);
8321
8322
8323         capabilities = rte_security_capabilities_get(ctx);
8324
8325         if (capabilities == NULL)
8326                 return -ENOTSUP;
8327
8328         while ((capability = &capabilities[i++])->action !=
8329                         RTE_SECURITY_ACTION_TYPE_NONE) {
8330                 if (capability->action == action &&
8331                                 capability->protocol == proto)
8332                         return 0;
8333         }
8334
8335         return -ENOTSUP;
8336 }
8337
8338 /* Basic algorithm run function for async inplace mode.
8339  * Creates a session from input parameters and runs one operation
8340  * on input_vec. Checks the output of the crypto operation against
8341  * output_vec.
8342  */
8343 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8344                            enum rte_crypto_auth_operation opa,
8345                            const uint8_t *input_vec, unsigned int input_vec_len,
8346                            const uint8_t *output_vec,
8347                            unsigned int output_vec_len,
8348                            enum rte_crypto_cipher_algorithm cipher_alg,
8349                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8350                            enum rte_crypto_auth_algorithm auth_alg,
8351                            const uint8_t *auth_key, uint32_t auth_key_len,
8352                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8353                            uint8_t packet_direction, uint8_t sn_size,
8354                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8355 {
8356         struct crypto_testsuite_params *ts_params = &testsuite_params;
8357         struct crypto_unittest_params *ut_params = &unittest_params;
8358         uint8_t *plaintext;
8359         int ret = TEST_SUCCESS;
8360         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8361                                 rte_cryptodev_get_sec_ctx(
8362                                 ts_params->valid_devs[0]);
8363
8364         /* Verify the capabilities */
8365         struct rte_security_capability_idx sec_cap_idx;
8366
8367         sec_cap_idx.action = ut_params->type;
8368         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8369         sec_cap_idx.pdcp.domain = domain;
8370         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8371                 return TEST_SKIPPED;
8372
8373         /* Generate test mbuf data */
8374         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8375
8376         /* clear mbuf payload */
8377         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8378                         rte_pktmbuf_tailroom(ut_params->ibuf));
8379
8380         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8381                                                   input_vec_len);
8382         memcpy(plaintext, input_vec, input_vec_len);
8383
8384         /* Out of place support */
8385         if (oop) {
8386                 /*
8387                  * For out-op-place we need to alloc another mbuf
8388                  */
8389                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8390                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8391         }
8392
8393         /* Setup Cipher Parameters */
8394         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8395         ut_params->cipher_xform.cipher.algo = cipher_alg;
8396         ut_params->cipher_xform.cipher.op = opc;
8397         ut_params->cipher_xform.cipher.key.data = cipher_key;
8398         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8399         ut_params->cipher_xform.cipher.iv.length =
8400                                 packet_direction ? 4 : 0;
8401         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8402
8403         /* Setup HMAC Parameters if ICV header is required */
8404         if (auth_alg != 0) {
8405                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8406                 ut_params->auth_xform.next = NULL;
8407                 ut_params->auth_xform.auth.algo = auth_alg;
8408                 ut_params->auth_xform.auth.op = opa;
8409                 ut_params->auth_xform.auth.key.data = auth_key;
8410                 ut_params->auth_xform.auth.key.length = auth_key_len;
8411
8412                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8413         } else {
8414                 ut_params->cipher_xform.next = NULL;
8415         }
8416
8417         struct rte_security_session_conf sess_conf = {
8418                 .action_type = ut_params->type,
8419                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8420                 {.pdcp = {
8421                         .bearer = bearer,
8422                         .domain = domain,
8423                         .pkt_dir = packet_direction,
8424                         .sn_size = sn_size,
8425                         .hfn = packet_direction ? 0 : hfn,
8426                         /**
8427                          * hfn can be set as pdcp_test_hfn[i]
8428                          * if hfn_ovrd is not set. Here, PDCP
8429                          * packet direction is just used to
8430                          * run half of the cases with session
8431                          * HFN and other half with per packet
8432                          * HFN.
8433                          */
8434                         .hfn_threshold = hfn_threshold,
8435                         .hfn_ovrd = packet_direction ? 1 : 0,
8436                         .sdap_enabled = sdap,
8437                 } },
8438                 .crypto_xform = &ut_params->cipher_xform
8439         };
8440
8441         /* Create security session */
8442         ut_params->sec_session = rte_security_session_create(ctx,
8443                                 &sess_conf, ts_params->session_mpool,
8444                                 ts_params->session_priv_mpool);
8445
8446         if (!ut_params->sec_session) {
8447                 printf("TestCase %s()-%d line %d failed %s: ",
8448                         __func__, i, __LINE__, "Failed to allocate session");
8449                 ret = TEST_FAILED;
8450                 goto on_err;
8451         }
8452
8453         /* Generate crypto op data structure */
8454         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8455                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8456         if (!ut_params->op) {
8457                 printf("TestCase %s()-%d line %d failed %s: ",
8458                         __func__, i, __LINE__,
8459                         "Failed to allocate symmetric crypto operation struct");
8460                 ret = TEST_FAILED;
8461                 goto on_err;
8462         }
8463
8464         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8465                                         uint32_t *, IV_OFFSET);
8466         *per_pkt_hfn = packet_direction ? hfn : 0;
8467
8468         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8469
8470         /* set crypto operation source mbuf */
8471         ut_params->op->sym->m_src = ut_params->ibuf;
8472         if (oop)
8473                 ut_params->op->sym->m_dst = ut_params->obuf;
8474
8475         /* Process crypto operation */
8476         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8477                 == NULL) {
8478                 printf("TestCase %s()-%d line %d failed %s: ",
8479                         __func__, i, __LINE__,
8480                         "failed to process sym crypto op");
8481                 ret = TEST_FAILED;
8482                 goto on_err;
8483         }
8484
8485         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8486                 printf("TestCase %s()-%d line %d failed %s: ",
8487                         __func__, i, __LINE__, "crypto op processing failed");
8488                 ret = TEST_FAILED;
8489                 goto on_err;
8490         }
8491
8492         /* Validate obuf */
8493         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8494                         uint8_t *);
8495         if (oop) {
8496                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8497                                 uint8_t *);
8498         }
8499
8500         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8501                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8502                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8503                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8504                 ret = TEST_FAILED;
8505                 goto on_err;
8506         }
8507
8508 on_err:
8509         rte_crypto_op_free(ut_params->op);
8510         ut_params->op = NULL;
8511
8512         if (ut_params->sec_session)
8513                 rte_security_session_destroy(ctx, ut_params->sec_session);
8514         ut_params->sec_session = NULL;
8515
8516         rte_pktmbuf_free(ut_params->ibuf);
8517         ut_params->ibuf = NULL;
8518         if (oop) {
8519                 rte_pktmbuf_free(ut_params->obuf);
8520                 ut_params->obuf = NULL;
8521         }
8522
8523         return ret;
8524 }
8525
8526 static int
8527 test_pdcp_proto_SGL(int i, int oop,
8528         enum rte_crypto_cipher_operation opc,
8529         enum rte_crypto_auth_operation opa,
8530         uint8_t *input_vec,
8531         unsigned int input_vec_len,
8532         uint8_t *output_vec,
8533         unsigned int output_vec_len,
8534         uint32_t fragsz,
8535         uint32_t fragsz_oop)
8536 {
8537         struct crypto_testsuite_params *ts_params = &testsuite_params;
8538         struct crypto_unittest_params *ut_params = &unittest_params;
8539         uint8_t *plaintext;
8540         struct rte_mbuf *buf, *buf_oop = NULL;
8541         int ret = TEST_SUCCESS;
8542         int to_trn = 0;
8543         int to_trn_tbl[16];
8544         int segs = 1;
8545         unsigned int trn_data = 0;
8546         struct rte_cryptodev_info dev_info;
8547         uint64_t feat_flags;
8548         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8549                                 rte_cryptodev_get_sec_ctx(
8550                                 ts_params->valid_devs[0]);
8551         struct rte_mbuf *temp_mbuf;
8552
8553         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8554         feat_flags = dev_info.feature_flags;
8555
8556         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8557                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8558                 printf("Device does not support RAW data-path APIs.\n");
8559                 return -ENOTSUP;
8560         }
8561         /* Verify the capabilities */
8562         struct rte_security_capability_idx sec_cap_idx;
8563
8564         sec_cap_idx.action = ut_params->type;
8565         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8566         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8567         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8568                 return TEST_SKIPPED;
8569
8570         if (fragsz > input_vec_len)
8571                 fragsz = input_vec_len;
8572
8573         uint16_t plaintext_len = fragsz;
8574         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8575
8576         if (fragsz_oop > output_vec_len)
8577                 frag_size_oop = output_vec_len;
8578
8579         int ecx = 0;
8580         if (input_vec_len % fragsz != 0) {
8581                 if (input_vec_len / fragsz + 1 > 16)
8582                         return 1;
8583         } else if (input_vec_len / fragsz > 16)
8584                 return 1;
8585
8586         /* Out of place support */
8587         if (oop) {
8588                 /*
8589                  * For out-op-place we need to alloc another mbuf
8590                  */
8591                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8592                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8593                 buf_oop = ut_params->obuf;
8594         }
8595
8596         /* Generate test mbuf data */
8597         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8598
8599         /* clear mbuf payload */
8600         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8601                         rte_pktmbuf_tailroom(ut_params->ibuf));
8602
8603         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8604                                                   plaintext_len);
8605         memcpy(plaintext, input_vec, plaintext_len);
8606         trn_data += plaintext_len;
8607
8608         buf = ut_params->ibuf;
8609
8610         /*
8611          * Loop until no more fragments
8612          */
8613
8614         while (trn_data < input_vec_len) {
8615                 ++segs;
8616                 to_trn = (input_vec_len - trn_data < fragsz) ?
8617                                 (input_vec_len - trn_data) : fragsz;
8618
8619                 to_trn_tbl[ecx++] = to_trn;
8620
8621                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8622                 buf = buf->next;
8623
8624                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8625                                 rte_pktmbuf_tailroom(buf));
8626
8627                 /* OOP */
8628                 if (oop && !fragsz_oop) {
8629                         buf_oop->next =
8630                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8631                         buf_oop = buf_oop->next;
8632                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8633                                         0, rte_pktmbuf_tailroom(buf_oop));
8634                         rte_pktmbuf_append(buf_oop, to_trn);
8635                 }
8636
8637                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8638                                 to_trn);
8639
8640                 memcpy(plaintext, input_vec + trn_data, to_trn);
8641                 trn_data += to_trn;
8642         }
8643
8644         ut_params->ibuf->nb_segs = segs;
8645
8646         segs = 1;
8647         if (fragsz_oop && oop) {
8648                 to_trn = 0;
8649                 ecx = 0;
8650
8651                 trn_data = frag_size_oop;
8652                 while (trn_data < output_vec_len) {
8653                         ++segs;
8654                         to_trn =
8655                                 (output_vec_len - trn_data <
8656                                                 frag_size_oop) ?
8657                                 (output_vec_len - trn_data) :
8658                                                 frag_size_oop;
8659
8660                         to_trn_tbl[ecx++] = to_trn;
8661
8662                         buf_oop->next =
8663                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8664                         buf_oop = buf_oop->next;
8665                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8666                                         0, rte_pktmbuf_tailroom(buf_oop));
8667                         rte_pktmbuf_append(buf_oop, to_trn);
8668
8669                         trn_data += to_trn;
8670                 }
8671                 ut_params->obuf->nb_segs = segs;
8672         }
8673
8674         /* Setup Cipher Parameters */
8675         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8676         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8677         ut_params->cipher_xform.cipher.op = opc;
8678         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8679         ut_params->cipher_xform.cipher.key.length =
8680                                         pdcp_test_params[i].cipher_key_len;
8681         ut_params->cipher_xform.cipher.iv.length = 0;
8682
8683         /* Setup HMAC Parameters if ICV header is required */
8684         if (pdcp_test_params[i].auth_alg != 0) {
8685                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8686                 ut_params->auth_xform.next = NULL;
8687                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8688                 ut_params->auth_xform.auth.op = opa;
8689                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8690                 ut_params->auth_xform.auth.key.length =
8691                                         pdcp_test_params[i].auth_key_len;
8692
8693                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8694         } else {
8695                 ut_params->cipher_xform.next = NULL;
8696         }
8697
8698         struct rte_security_session_conf sess_conf = {
8699                 .action_type = ut_params->type,
8700                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8701                 {.pdcp = {
8702                         .bearer = pdcp_test_bearer[i],
8703                         .domain = pdcp_test_params[i].domain,
8704                         .pkt_dir = pdcp_test_packet_direction[i],
8705                         .sn_size = pdcp_test_data_sn_size[i],
8706                         .hfn = pdcp_test_hfn[i],
8707                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8708                         .hfn_ovrd = 0,
8709                 } },
8710                 .crypto_xform = &ut_params->cipher_xform
8711         };
8712
8713         /* Create security session */
8714         ut_params->sec_session = rte_security_session_create(ctx,
8715                                 &sess_conf, ts_params->session_mpool,
8716                                 ts_params->session_priv_mpool);
8717
8718         if (!ut_params->sec_session) {
8719                 printf("TestCase %s()-%d line %d failed %s: ",
8720                         __func__, i, __LINE__, "Failed to allocate session");
8721                 ret = TEST_FAILED;
8722                 goto on_err;
8723         }
8724
8725         /* Generate crypto op data structure */
8726         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8727                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8728         if (!ut_params->op) {
8729                 printf("TestCase %s()-%d line %d failed %s: ",
8730                         __func__, i, __LINE__,
8731                         "Failed to allocate symmetric crypto operation struct");
8732                 ret = TEST_FAILED;
8733                 goto on_err;
8734         }
8735
8736         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8737
8738         /* set crypto operation source mbuf */
8739         ut_params->op->sym->m_src = ut_params->ibuf;
8740         if (oop)
8741                 ut_params->op->sym->m_dst = ut_params->obuf;
8742
8743         /* Process crypto operation */
8744         temp_mbuf = ut_params->op->sym->m_src;
8745         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8746                 /* filling lengths */
8747                 while (temp_mbuf) {
8748                         ut_params->op->sym->cipher.data.length
8749                                 += temp_mbuf->pkt_len;
8750                         ut_params->op->sym->auth.data.length
8751                                 += temp_mbuf->pkt_len;
8752                         temp_mbuf = temp_mbuf->next;
8753                 }
8754                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8755                         ut_params->op, 1, 1, 0, 0);
8756         } else {
8757                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8758                                                         ut_params->op);
8759         }
8760         if (ut_params->op == NULL) {
8761                 printf("TestCase %s()-%d line %d failed %s: ",
8762                         __func__, i, __LINE__,
8763                         "failed to process sym crypto op");
8764                 ret = TEST_FAILED;
8765                 goto on_err;
8766         }
8767
8768         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8769                 printf("TestCase %s()-%d line %d failed %s: ",
8770                         __func__, i, __LINE__, "crypto op processing failed");
8771                 ret = TEST_FAILED;
8772                 goto on_err;
8773         }
8774
8775         /* Validate obuf */
8776         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8777                         uint8_t *);
8778         if (oop) {
8779                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8780                                 uint8_t *);
8781         }
8782         if (fragsz_oop)
8783                 fragsz = frag_size_oop;
8784         if (memcmp(ciphertext, output_vec, fragsz)) {
8785                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8786                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8787                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8788                 ret = TEST_FAILED;
8789                 goto on_err;
8790         }
8791
8792         buf = ut_params->op->sym->m_src->next;
8793         if (oop)
8794                 buf = ut_params->op->sym->m_dst->next;
8795
8796         unsigned int off = fragsz;
8797
8798         ecx = 0;
8799         while (buf) {
8800                 ciphertext = rte_pktmbuf_mtod(buf,
8801                                 uint8_t *);
8802                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8803                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8804                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8805                         rte_hexdump(stdout, "reference", output_vec + off,
8806                                         to_trn_tbl[ecx]);
8807                         ret = TEST_FAILED;
8808                         goto on_err;
8809                 }
8810                 off += to_trn_tbl[ecx++];
8811                 buf = buf->next;
8812         }
8813 on_err:
8814         rte_crypto_op_free(ut_params->op);
8815         ut_params->op = NULL;
8816
8817         if (ut_params->sec_session)
8818                 rte_security_session_destroy(ctx, ut_params->sec_session);
8819         ut_params->sec_session = NULL;
8820
8821         rte_pktmbuf_free(ut_params->ibuf);
8822         ut_params->ibuf = NULL;
8823         if (oop) {
8824                 rte_pktmbuf_free(ut_params->obuf);
8825                 ut_params->obuf = NULL;
8826         }
8827
8828         return ret;
8829 }
8830
8831 int
8832 test_pdcp_proto_cplane_encap(int i)
8833 {
8834         return test_pdcp_proto(
8835                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8836                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8837                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8838                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8839                 pdcp_test_params[i].cipher_key_len,
8840                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8841                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8842                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8843                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8844                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8845 }
8846
8847 int
8848 test_pdcp_proto_uplane_encap(int i)
8849 {
8850         return test_pdcp_proto(
8851                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8852                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8853                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8854                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8855                 pdcp_test_params[i].cipher_key_len,
8856                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8857                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8858                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8859                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8860                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8861 }
8862
8863 int
8864 test_pdcp_proto_uplane_encap_with_int(int i)
8865 {
8866         return test_pdcp_proto(
8867                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8868                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8869                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8870                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8871                 pdcp_test_params[i].cipher_key_len,
8872                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8873                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8874                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8875                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8876                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8877 }
8878
8879 int
8880 test_pdcp_proto_cplane_decap(int i)
8881 {
8882         return test_pdcp_proto(
8883                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8884                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8885                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8886                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8887                 pdcp_test_params[i].cipher_key_len,
8888                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8889                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8890                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8891                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8892                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8893 }
8894
8895 int
8896 test_pdcp_proto_uplane_decap(int i)
8897 {
8898         return test_pdcp_proto(
8899                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8900                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8901                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8902                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8903                 pdcp_test_params[i].cipher_key_len,
8904                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8905                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8906                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8907                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8908                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8909 }
8910
8911 int
8912 test_pdcp_proto_uplane_decap_with_int(int i)
8913 {
8914         return test_pdcp_proto(
8915                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8916                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8917                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8918                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8919                 pdcp_test_params[i].cipher_key_len,
8920                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8921                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8922                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8923                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8924                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8925 }
8926
8927 static int
8928 test_PDCP_PROTO_SGL_in_place_32B(void)
8929 {
8930         /* i can be used for running any PDCP case
8931          * In this case it is uplane 12-bit AES-SNOW DL encap
8932          */
8933         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8934         return test_pdcp_proto_SGL(i, IN_PLACE,
8935                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8936                         RTE_CRYPTO_AUTH_OP_GENERATE,
8937                         pdcp_test_data_in[i],
8938                         pdcp_test_data_in_len[i],
8939                         pdcp_test_data_out[i],
8940                         pdcp_test_data_in_len[i]+4,
8941                         32, 0);
8942 }
8943 static int
8944 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8945 {
8946         /* i can be used for running any PDCP case
8947          * In this case it is uplane 18-bit NULL-NULL DL encap
8948          */
8949         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8950         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8951                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8952                         RTE_CRYPTO_AUTH_OP_GENERATE,
8953                         pdcp_test_data_in[i],
8954                         pdcp_test_data_in_len[i],
8955                         pdcp_test_data_out[i],
8956                         pdcp_test_data_in_len[i]+4,
8957                         32, 128);
8958 }
8959 static int
8960 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8961 {
8962         /* i can be used for running any PDCP case
8963          * In this case it is uplane 18-bit AES DL encap
8964          */
8965         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8966                         + DOWNLINK;
8967         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8968                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8969                         RTE_CRYPTO_AUTH_OP_GENERATE,
8970                         pdcp_test_data_in[i],
8971                         pdcp_test_data_in_len[i],
8972                         pdcp_test_data_out[i],
8973                         pdcp_test_data_in_len[i],
8974                         32, 40);
8975 }
8976 static int
8977 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8978 {
8979         /* i can be used for running any PDCP case
8980          * In this case it is cplane 12-bit AES-ZUC DL encap
8981          */
8982         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8983         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8984                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8985                         RTE_CRYPTO_AUTH_OP_GENERATE,
8986                         pdcp_test_data_in[i],
8987                         pdcp_test_data_in_len[i],
8988                         pdcp_test_data_out[i],
8989                         pdcp_test_data_in_len[i]+4,
8990                         128, 32);
8991 }
8992
8993 static int
8994 test_PDCP_SDAP_PROTO_encap_all(void)
8995 {
8996         int i = 0, size = 0;
8997         int err, all_err = TEST_SUCCESS;
8998         const struct pdcp_sdap_test *cur_test;
8999
9000         size = RTE_DIM(list_pdcp_sdap_tests);
9001
9002         for (i = 0; i < size; i++) {
9003                 cur_test = &list_pdcp_sdap_tests[i];
9004                 err = test_pdcp_proto(
9005                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9006                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9007                         cur_test->in_len, cur_test->data_out,
9008                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9009                         cur_test->param.cipher_alg, cur_test->cipher_key,
9010                         cur_test->param.cipher_key_len,
9011                         cur_test->param.auth_alg,
9012                         cur_test->auth_key, cur_test->param.auth_key_len,
9013                         cur_test->bearer, cur_test->param.domain,
9014                         cur_test->packet_direction, cur_test->sn_size,
9015                         cur_test->hfn,
9016                         cur_test->hfn_threshold, SDAP_ENABLED);
9017                 if (err) {
9018                         printf("\t%d) %s: Encapsulation failed\n",
9019                                         cur_test->test_idx,
9020                                         cur_test->param.name);
9021                         err = TEST_FAILED;
9022                 } else {
9023                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9024                                         cur_test->param.name);
9025                         err = TEST_SUCCESS;
9026                 }
9027                 all_err += err;
9028         }
9029
9030         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9031
9032         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9033 }
9034
9035 static int
9036 test_PDCP_PROTO_short_mac(void)
9037 {
9038         int i = 0, size = 0;
9039         int err, all_err = TEST_SUCCESS;
9040         const struct pdcp_short_mac_test *cur_test;
9041
9042         size = RTE_DIM(list_pdcp_smac_tests);
9043
9044         for (i = 0; i < size; i++) {
9045                 cur_test = &list_pdcp_smac_tests[i];
9046                 err = test_pdcp_proto(
9047                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9048                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9049                         cur_test->in_len, cur_test->data_out,
9050                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9051                         RTE_CRYPTO_CIPHER_NULL, NULL,
9052                         0, cur_test->param.auth_alg,
9053                         cur_test->auth_key, cur_test->param.auth_key_len,
9054                         0, cur_test->param.domain, 0, 0,
9055                         0, 0, 0);
9056                 if (err) {
9057                         printf("\t%d) %s: Short MAC test failed\n",
9058                                         cur_test->test_idx,
9059                                         cur_test->param.name);
9060                         err = TEST_FAILED;
9061                 } else {
9062                         printf("\t%d) %s: Short MAC test PASS\n",
9063                                         cur_test->test_idx,
9064                                         cur_test->param.name);
9065                         rte_hexdump(stdout, "MAC I",
9066                                     cur_test->data_out + cur_test->in_len + 2,
9067                                     2);
9068                         err = TEST_SUCCESS;
9069                 }
9070                 all_err += err;
9071         }
9072
9073         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9074
9075         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9076
9077 }
9078
9079 static int
9080 test_PDCP_SDAP_PROTO_decap_all(void)
9081 {
9082         int i = 0, size = 0;
9083         int err, all_err = TEST_SUCCESS;
9084         const struct pdcp_sdap_test *cur_test;
9085
9086         size = RTE_DIM(list_pdcp_sdap_tests);
9087
9088         for (i = 0; i < size; i++) {
9089                 cur_test = &list_pdcp_sdap_tests[i];
9090                 err = test_pdcp_proto(
9091                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9092                         RTE_CRYPTO_AUTH_OP_VERIFY,
9093                         cur_test->data_out,
9094                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9095                         cur_test->data_in, cur_test->in_len,
9096                         cur_test->param.cipher_alg,
9097                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9098                         cur_test->param.auth_alg, cur_test->auth_key,
9099                         cur_test->param.auth_key_len, cur_test->bearer,
9100                         cur_test->param.domain, cur_test->packet_direction,
9101                         cur_test->sn_size, cur_test->hfn,
9102                         cur_test->hfn_threshold, SDAP_ENABLED);
9103                 if (err) {
9104                         printf("\t%d) %s: Decapsulation failed\n",
9105                                         cur_test->test_idx,
9106                                         cur_test->param.name);
9107                         err = TEST_FAILED;
9108                 } else {
9109                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9110                                         cur_test->param.name);
9111                         err = TEST_SUCCESS;
9112                 }
9113                 all_err += err;
9114         }
9115
9116         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9117
9118         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9119 }
9120
9121 static int
9122 test_ipsec_proto_process(const struct ipsec_test_data td[],
9123                          struct ipsec_test_data res_d[],
9124                          int nb_td,
9125                          bool silent,
9126                          const struct ipsec_test_flags *flags)
9127 {
9128         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9129                                 0x0000, 0x001a};
9130         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9131                                 0xe82c, 0x4887};
9132         struct crypto_testsuite_params *ts_params = &testsuite_params;
9133         struct crypto_unittest_params *ut_params = &unittest_params;
9134         struct rte_security_capability_idx sec_cap_idx;
9135         const struct rte_security_capability *sec_cap;
9136         struct rte_security_ipsec_xform ipsec_xform;
9137         uint8_t dev_id = ts_params->valid_devs[0];
9138         enum rte_security_ipsec_sa_direction dir;
9139         struct ipsec_test_data *res_d_tmp = NULL;
9140         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9141         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9142         int salt_len, i, ret = TEST_SUCCESS;
9143         struct rte_security_ctx *ctx;
9144         uint8_t *input_text;
9145         uint32_t verify;
9146
9147         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9148         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9149
9150         /* Use first test data to create session */
9151
9152         /* Copy IPsec xform */
9153         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9154
9155         dir = ipsec_xform.direction;
9156         verify = flags->tunnel_hdr_verify;
9157
9158         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9159                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9160                         src += 1;
9161                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9162                         dst += 1;
9163         }
9164
9165         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9166                 if (td->ipsec_xform.tunnel.type ==
9167                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9168                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9169                                sizeof(src));
9170                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9171                                sizeof(dst));
9172                 } else {
9173                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9174                                sizeof(v6_src));
9175                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9176                                sizeof(v6_dst));
9177                 }
9178         }
9179
9180         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9181
9182         sec_cap_idx.action = ut_params->type;
9183         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9184         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9185         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9186         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9187
9188         if (flags->udp_encap)
9189                 ipsec_xform.options.udp_encap = 1;
9190
9191         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9192         if (sec_cap == NULL)
9193                 return TEST_SKIPPED;
9194
9195         /* Copy cipher session parameters */
9196         if (td[0].aead) {
9197                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9198                        sizeof(ut_params->aead_xform));
9199                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9200                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9201
9202                 /* Verify crypto capabilities */
9203                 if (test_ipsec_crypto_caps_aead_verify(
9204                                 sec_cap,
9205                                 &ut_params->aead_xform) != 0) {
9206                         if (!silent)
9207                                 RTE_LOG(INFO, USER1,
9208                                         "Crypto capabilities not supported\n");
9209                         return TEST_SKIPPED;
9210                 }
9211         } else {
9212                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9213                        sizeof(ut_params->cipher_xform));
9214                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9215                        sizeof(ut_params->auth_xform));
9216                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9217                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9218                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9219
9220                 /* Verify crypto capabilities */
9221
9222                 if (test_ipsec_crypto_caps_cipher_verify(
9223                                 sec_cap,
9224                                 &ut_params->cipher_xform) != 0) {
9225                         if (!silent)
9226                                 RTE_LOG(INFO, USER1,
9227                                         "Cipher crypto capabilities not supported\n");
9228                         return TEST_SKIPPED;
9229                 }
9230
9231                 if (test_ipsec_crypto_caps_auth_verify(
9232                                 sec_cap,
9233                                 &ut_params->auth_xform) != 0) {
9234                         if (!silent)
9235                                 RTE_LOG(INFO, USER1,
9236                                         "Auth crypto capabilities not supported\n");
9237                         return TEST_SKIPPED;
9238                 }
9239         }
9240
9241         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9242                 return TEST_SKIPPED;
9243
9244         struct rte_security_session_conf sess_conf = {
9245                 .action_type = ut_params->type,
9246                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9247         };
9248
9249         if (td[0].aead) {
9250                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9251                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9252                 sess_conf.ipsec = ipsec_xform;
9253                 sess_conf.crypto_xform = &ut_params->aead_xform;
9254         } else {
9255                 sess_conf.ipsec = ipsec_xform;
9256                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9257                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9258                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9259                 } else {
9260                         sess_conf.crypto_xform = &ut_params->auth_xform;
9261                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9262                 }
9263         }
9264
9265         /* Create security session */
9266         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9267                                         ts_params->session_mpool,
9268                                         ts_params->session_priv_mpool);
9269
9270         if (ut_params->sec_session == NULL)
9271                 return TEST_SKIPPED;
9272
9273         for (i = 0; i < nb_td; i++) {
9274                 /* Setup source mbuf payload */
9275                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9276                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9277                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9278
9279                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9280                                 td[i].input_text.len);
9281
9282                 memcpy(input_text, td[i].input_text.data,
9283                        td[i].input_text.len);
9284
9285                 /* Generate crypto op data structure */
9286                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9287                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9288                 if (!ut_params->op) {
9289                         printf("TestCase %s line %d: %s\n",
9290                                 __func__, __LINE__,
9291                                 "failed to allocate crypto op");
9292                         ret = TEST_FAILED;
9293                         goto crypto_op_free;
9294                 }
9295
9296                 /* Attach session to operation */
9297                 rte_security_attach_session(ut_params->op,
9298                                             ut_params->sec_session);
9299
9300                 /* Set crypto operation mbufs */
9301                 ut_params->op->sym->m_src = ut_params->ibuf;
9302                 ut_params->op->sym->m_dst = NULL;
9303
9304                 /* Copy IV in crypto operation when IV generation is disabled */
9305                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9306                     ipsec_xform.options.iv_gen_disable == 1) {
9307                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9308                                                                 uint8_t *,
9309                                                                 IV_OFFSET);
9310                         int len;
9311
9312                         if (td[i].aead)
9313                                 len = td[i].xform.aead.aead.iv.length;
9314                         else
9315                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9316
9317                         memcpy(iv, td[i].iv.data, len);
9318                 }
9319
9320                 /* Process crypto operation */
9321                 process_crypto_request(dev_id, ut_params->op);
9322
9323                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9324                 if (ret != TEST_SUCCESS)
9325                         goto crypto_op_free;
9326
9327                 if (res_d != NULL)
9328                         res_d_tmp = &res_d[i];
9329
9330                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9331                                               res_d_tmp, silent, flags);
9332                 if (ret != TEST_SUCCESS)
9333                         goto crypto_op_free;
9334
9335                 rte_crypto_op_free(ut_params->op);
9336                 ut_params->op = NULL;
9337
9338                 rte_pktmbuf_free(ut_params->ibuf);
9339                 ut_params->ibuf = NULL;
9340         }
9341
9342 crypto_op_free:
9343         rte_crypto_op_free(ut_params->op);
9344         ut_params->op = NULL;
9345
9346         rte_pktmbuf_free(ut_params->ibuf);
9347         ut_params->ibuf = NULL;
9348
9349         if (ut_params->sec_session)
9350                 rte_security_session_destroy(ctx, ut_params->sec_session);
9351         ut_params->sec_session = NULL;
9352
9353         return ret;
9354 }
9355
9356 static int
9357 test_ipsec_proto_known_vec(const void *test_data)
9358 {
9359         struct ipsec_test_data td_outb;
9360         struct ipsec_test_flags flags;
9361
9362         memset(&flags, 0, sizeof(flags));
9363
9364         memcpy(&td_outb, test_data, sizeof(td_outb));
9365
9366         /* Disable IV gen to be able to test with known vectors */
9367         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9368
9369         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9370 }
9371
9372 static int
9373 test_ipsec_proto_known_vec_inb(const void *test_data)
9374 {
9375         const struct ipsec_test_data *td = test_data;
9376         struct ipsec_test_flags flags;
9377         struct ipsec_test_data td_inb;
9378
9379         memset(&flags, 0, sizeof(flags));
9380
9381         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9382                 test_ipsec_td_in_from_out(td, &td_inb);
9383         else
9384                 memcpy(&td_inb, td, sizeof(td_inb));
9385
9386         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9387 }
9388
9389 static int
9390 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9391 {
9392         struct ipsec_test_data td_outb;
9393         struct ipsec_test_flags flags;
9394
9395         memset(&flags, 0, sizeof(flags));
9396         flags.fragment = true;
9397
9398         memcpy(&td_outb, test_data, sizeof(td_outb));
9399
9400         /* Disable IV gen to be able to test with known vectors */
9401         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9402
9403         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9404 }
9405
9406 static int
9407 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9408 {
9409         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9410         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9411         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9412         int ret;
9413
9414         if (flags->iv_gen ||
9415             flags->sa_expiry_pkts_soft ||
9416             flags->sa_expiry_pkts_hard)
9417                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9418
9419         for (i = 0; i < RTE_DIM(alg_list); i++) {
9420                 test_ipsec_td_prepare(alg_list[i].param1,
9421                                       alg_list[i].param2,
9422                                       flags,
9423                                       td_outb,
9424                                       nb_pkts);
9425
9426                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9427                                                flags);
9428                 if (ret == TEST_SKIPPED)
9429                         continue;
9430
9431                 if (ret == TEST_FAILED)
9432                         return TEST_FAILED;
9433
9434                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9435
9436                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9437                                                flags);
9438                 if (ret == TEST_SKIPPED)
9439                         continue;
9440
9441                 if (ret == TEST_FAILED)
9442                         return TEST_FAILED;
9443
9444                 if (flags->display_alg)
9445                         test_ipsec_display_alg(alg_list[i].param1,
9446                                                alg_list[i].param2);
9447
9448                 pass_cnt++;
9449         }
9450
9451         if (pass_cnt > 0)
9452                 return TEST_SUCCESS;
9453         else
9454                 return TEST_SKIPPED;
9455 }
9456
9457 static int
9458 test_ipsec_proto_display_list(const void *data __rte_unused)
9459 {
9460         struct ipsec_test_flags flags;
9461
9462         memset(&flags, 0, sizeof(flags));
9463
9464         flags.display_alg = true;
9465
9466         return test_ipsec_proto_all(&flags);
9467 }
9468
9469 static int
9470 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9471 {
9472         struct ipsec_test_flags flags;
9473
9474         memset(&flags, 0, sizeof(flags));
9475
9476         flags.iv_gen = true;
9477
9478         return test_ipsec_proto_all(&flags);
9479 }
9480
9481 static int
9482 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9483 {
9484         struct ipsec_test_flags flags;
9485
9486         memset(&flags, 0, sizeof(flags));
9487
9488         flags.sa_expiry_pkts_soft = true;
9489
9490         return test_ipsec_proto_all(&flags);
9491 }
9492
9493 static int
9494 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9495 {
9496         struct ipsec_test_flags flags;
9497
9498         memset(&flags, 0, sizeof(flags));
9499
9500         flags.sa_expiry_pkts_hard = true;
9501
9502         return test_ipsec_proto_all(&flags);
9503 }
9504
9505 static int
9506 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9507 {
9508         struct ipsec_test_flags flags;
9509
9510         memset(&flags, 0, sizeof(flags));
9511
9512         flags.icv_corrupt = true;
9513
9514         return test_ipsec_proto_all(&flags);
9515 }
9516
9517 static int
9518 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9519 {
9520         struct ipsec_test_flags flags;
9521
9522         memset(&flags, 0, sizeof(flags));
9523
9524         flags.udp_encap = true;
9525
9526         return test_ipsec_proto_all(&flags);
9527 }
9528
9529 static int
9530 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9531 {
9532         struct ipsec_test_flags flags;
9533
9534         memset(&flags, 0, sizeof(flags));
9535
9536         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9537
9538         return test_ipsec_proto_all(&flags);
9539 }
9540
9541 static int
9542 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9543 {
9544         struct ipsec_test_flags flags;
9545
9546         memset(&flags, 0, sizeof(flags));
9547
9548         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9549
9550         return test_ipsec_proto_all(&flags);
9551 }
9552
9553 static int
9554 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9555 {
9556         struct ipsec_test_flags flags;
9557
9558         memset(&flags, 0, sizeof(flags));
9559
9560         flags.udp_encap = true;
9561         flags.udp_ports_verify = true;
9562
9563         return test_ipsec_proto_all(&flags);
9564 }
9565
9566 static int
9567 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9568 {
9569         struct ipsec_test_flags flags;
9570
9571         memset(&flags, 0, sizeof(flags));
9572
9573         flags.ip_csum = true;
9574
9575         return test_ipsec_proto_all(&flags);
9576 }
9577
9578 static int
9579 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9580 {
9581         struct ipsec_test_flags flags;
9582
9583         memset(&flags, 0, sizeof(flags));
9584
9585         flags.l4_csum = true;
9586
9587         return test_ipsec_proto_all(&flags);
9588 }
9589
9590 static int
9591 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9592 {
9593         struct ipsec_test_flags flags;
9594
9595         memset(&flags, 0, sizeof(flags));
9596
9597         flags.ipv6 = false;
9598         flags.tunnel_ipv6 = false;
9599
9600         return test_ipsec_proto_all(&flags);
9601 }
9602
9603 static int
9604 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9605 {
9606         struct ipsec_test_flags flags;
9607
9608         memset(&flags, 0, sizeof(flags));
9609
9610         flags.ipv6 = true;
9611         flags.tunnel_ipv6 = true;
9612
9613         return test_ipsec_proto_all(&flags);
9614 }
9615
9616 static int
9617 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9618 {
9619         struct ipsec_test_flags flags;
9620
9621         memset(&flags, 0, sizeof(flags));
9622
9623         flags.ipv6 = false;
9624         flags.tunnel_ipv6 = true;
9625
9626         return test_ipsec_proto_all(&flags);
9627 }
9628
9629 static int
9630 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9631 {
9632         struct ipsec_test_flags flags;
9633
9634         memset(&flags, 0, sizeof(flags));
9635
9636         flags.ipv6 = true;
9637         flags.tunnel_ipv6 = false;
9638
9639         return test_ipsec_proto_all(&flags);
9640 }
9641
9642 static int
9643 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9644 {
9645         struct ipsec_test_flags flags;
9646
9647         memset(&flags, 0, sizeof(flags));
9648
9649         flags.ipv6 = false;
9650         flags.transport = true;
9651
9652         return test_ipsec_proto_all(&flags);
9653 }
9654
9655 static int
9656 test_PDCP_PROTO_all(void)
9657 {
9658         struct crypto_testsuite_params *ts_params = &testsuite_params;
9659         struct crypto_unittest_params *ut_params = &unittest_params;
9660         struct rte_cryptodev_info dev_info;
9661         int status;
9662
9663         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9664         uint64_t feat_flags = dev_info.feature_flags;
9665
9666         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9667                 return TEST_SKIPPED;
9668
9669         /* Set action type */
9670         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9671                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9672                 gbl_action_type;
9673
9674         if (security_proto_supported(ut_params->type,
9675                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9676                 return TEST_SKIPPED;
9677
9678         status = test_PDCP_PROTO_cplane_encap_all();
9679         status += test_PDCP_PROTO_cplane_decap_all();
9680         status += test_PDCP_PROTO_uplane_encap_all();
9681         status += test_PDCP_PROTO_uplane_decap_all();
9682         status += test_PDCP_PROTO_SGL_in_place_32B();
9683         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9684         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9685         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9686         status += test_PDCP_SDAP_PROTO_encap_all();
9687         status += test_PDCP_SDAP_PROTO_decap_all();
9688         status += test_PDCP_PROTO_short_mac();
9689
9690         if (status)
9691                 return TEST_FAILED;
9692         else
9693                 return TEST_SUCCESS;
9694 }
9695
9696 static int
9697 test_docsis_proto_uplink(const void *data)
9698 {
9699         const struct docsis_test_data *d_td = data;
9700         struct crypto_testsuite_params *ts_params = &testsuite_params;
9701         struct crypto_unittest_params *ut_params = &unittest_params;
9702         uint8_t *plaintext = NULL;
9703         uint8_t *ciphertext = NULL;
9704         uint8_t *iv_ptr;
9705         int32_t cipher_len, crc_len;
9706         uint32_t crc_data_len;
9707         int ret = TEST_SUCCESS;
9708
9709         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9710                                         rte_cryptodev_get_sec_ctx(
9711                                                 ts_params->valid_devs[0]);
9712
9713         /* Verify the capabilities */
9714         struct rte_security_capability_idx sec_cap_idx;
9715         const struct rte_security_capability *sec_cap;
9716         const struct rte_cryptodev_capabilities *crypto_cap;
9717         const struct rte_cryptodev_symmetric_capability *sym_cap;
9718         int j = 0;
9719
9720         /* Set action type */
9721         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9722                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9723                 gbl_action_type;
9724
9725         if (security_proto_supported(ut_params->type,
9726                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9727                 return TEST_SKIPPED;
9728
9729         sec_cap_idx.action = ut_params->type;
9730         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9731         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9732
9733         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9734         if (sec_cap == NULL)
9735                 return TEST_SKIPPED;
9736
9737         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9738                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9739                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9740                                 crypto_cap->sym.xform_type ==
9741                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9742                                 crypto_cap->sym.cipher.algo ==
9743                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9744                         sym_cap = &crypto_cap->sym;
9745                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9746                                                 d_td->key.len,
9747                                                 d_td->iv.len) == 0)
9748                                 break;
9749                 }
9750         }
9751
9752         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9753                 return TEST_SKIPPED;
9754
9755         /* Setup source mbuf payload */
9756         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9757         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9758                         rte_pktmbuf_tailroom(ut_params->ibuf));
9759
9760         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9761                         d_td->ciphertext.len);
9762
9763         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
9764
9765         /* Setup cipher session parameters */
9766         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9767         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9768         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
9769         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9770         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9771         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9772         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9773         ut_params->cipher_xform.next = NULL;
9774
9775         /* Setup DOCSIS session parameters */
9776         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
9777
9778         struct rte_security_session_conf sess_conf = {
9779                 .action_type = ut_params->type,
9780                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9781                 .docsis = ut_params->docsis_xform,
9782                 .crypto_xform = &ut_params->cipher_xform,
9783         };
9784
9785         /* Create security session */
9786         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9787                                         ts_params->session_mpool,
9788                                         ts_params->session_priv_mpool);
9789
9790         if (!ut_params->sec_session) {
9791                 printf("Test function %s line %u: failed to allocate session\n",
9792                         __func__, __LINE__);
9793                 ret = TEST_FAILED;
9794                 goto on_err;
9795         }
9796
9797         /* Generate crypto op data structure */
9798         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9799                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9800         if (!ut_params->op) {
9801                 printf("Test function %s line %u: failed to allocate symmetric "
9802                         "crypto operation\n", __func__, __LINE__);
9803                 ret = TEST_FAILED;
9804                 goto on_err;
9805         }
9806
9807         /* Setup CRC operation parameters */
9808         crc_len = d_td->ciphertext.no_crc == false ?
9809                         (d_td->ciphertext.len -
9810                                 d_td->ciphertext.crc_offset -
9811                                 RTE_ETHER_CRC_LEN) :
9812                         0;
9813         crc_len = crc_len > 0 ? crc_len : 0;
9814         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
9815         ut_params->op->sym->auth.data.length = crc_len;
9816         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
9817
9818         /* Setup cipher operation parameters */
9819         cipher_len = d_td->ciphertext.no_cipher == false ?
9820                         (d_td->ciphertext.len -
9821                                 d_td->ciphertext.cipher_offset) :
9822                         0;
9823         cipher_len = cipher_len > 0 ? cipher_len : 0;
9824         ut_params->op->sym->cipher.data.length = cipher_len;
9825         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
9826
9827         /* Setup cipher IV */
9828         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
9829         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
9830
9831         /* Attach session to operation */
9832         rte_security_attach_session(ut_params->op, ut_params->sec_session);
9833
9834         /* Set crypto operation mbufs */
9835         ut_params->op->sym->m_src = ut_params->ibuf;
9836         ut_params->op->sym->m_dst = NULL;
9837
9838         /* Process crypto operation */
9839         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
9840                         NULL) {
9841                 printf("Test function %s line %u: failed to process security "
9842                         "crypto op\n", __func__, __LINE__);
9843                 ret = TEST_FAILED;
9844                 goto on_err;
9845         }
9846
9847         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
9848                 printf("Test function %s line %u: failed to process crypto op\n",
9849                         __func__, __LINE__);
9850                 ret = TEST_FAILED;
9851                 goto on_err;
9852         }
9853
9854         /* Validate plaintext */
9855         plaintext = ciphertext;
9856
9857         if (memcmp(plaintext, d_td->plaintext.data,
9858                         d_td->plaintext.len - crc_data_len)) {
9859                 printf("Test function %s line %u: plaintext not as expected\n",
9860                         __func__, __LINE__);
9861                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
9862                                 d_td->plaintext.len);
9863                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
9864                 ret = TEST_FAILED;
9865                 goto on_err;
9866         }
9867
9868 on_err:
9869         rte_crypto_op_free(ut_params->op);
9870         ut_params->op = NULL;
9871
9872         if (ut_params->sec_session)
9873                 rte_security_session_destroy(ctx, ut_params->sec_session);
9874         ut_params->sec_session = NULL;
9875
9876         rte_pktmbuf_free(ut_params->ibuf);
9877         ut_params->ibuf = NULL;
9878
9879         return ret;
9880 }
9881
9882 static int
9883 test_docsis_proto_downlink(const void *data)
9884 {
9885         const struct docsis_test_data *d_td = data;
9886         struct crypto_testsuite_params *ts_params = &testsuite_params;
9887         struct crypto_unittest_params *ut_params = &unittest_params;
9888         uint8_t *plaintext = NULL;
9889         uint8_t *ciphertext = NULL;
9890         uint8_t *iv_ptr;
9891         int32_t cipher_len, crc_len;
9892         int ret = TEST_SUCCESS;
9893
9894         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9895                                         rte_cryptodev_get_sec_ctx(
9896                                                 ts_params->valid_devs[0]);
9897
9898         /* Verify the capabilities */
9899         struct rte_security_capability_idx sec_cap_idx;
9900         const struct rte_security_capability *sec_cap;
9901         const struct rte_cryptodev_capabilities *crypto_cap;
9902         const struct rte_cryptodev_symmetric_capability *sym_cap;
9903         int j = 0;
9904
9905         /* Set action type */
9906         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9907                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9908                 gbl_action_type;
9909
9910         if (security_proto_supported(ut_params->type,
9911                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9912                 return TEST_SKIPPED;
9913
9914         sec_cap_idx.action = ut_params->type;
9915         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9916         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9917
9918         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9919         if (sec_cap == NULL)
9920                 return TEST_SKIPPED;
9921
9922         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9923                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9924                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9925                                 crypto_cap->sym.xform_type ==
9926                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9927                                 crypto_cap->sym.cipher.algo ==
9928                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9929                         sym_cap = &crypto_cap->sym;
9930                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9931                                                 d_td->key.len,
9932                                                 d_td->iv.len) == 0)
9933                                 break;
9934                 }
9935         }
9936
9937         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
9938                 return TEST_SKIPPED;
9939
9940         /* Setup source mbuf payload */
9941         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9942         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9943                         rte_pktmbuf_tailroom(ut_params->ibuf));
9944
9945         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9946                         d_td->plaintext.len);
9947
9948         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
9949
9950         /* Setup cipher session parameters */
9951         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
9952         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
9953         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
9954         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
9955         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
9956         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
9957         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9958         ut_params->cipher_xform.next = NULL;
9959
9960         /* Setup DOCSIS session parameters */
9961         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
9962
9963         struct rte_security_session_conf sess_conf = {
9964                 .action_type = ut_params->type,
9965                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
9966                 .docsis = ut_params->docsis_xform,
9967                 .crypto_xform = &ut_params->cipher_xform,
9968         };
9969
9970         /* Create security session */
9971         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9972                                         ts_params->session_mpool,
9973                                         ts_params->session_priv_mpool);
9974
9975         if (!ut_params->sec_session) {
9976                 printf("Test function %s line %u: failed to allocate session\n",
9977                         __func__, __LINE__);
9978                 ret = TEST_FAILED;
9979                 goto on_err;
9980         }
9981
9982         /* Generate crypto op data structure */
9983         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9984                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9985         if (!ut_params->op) {
9986                 printf("Test function %s line %u: failed to allocate symmetric "
9987                         "crypto operation\n", __func__, __LINE__);
9988                 ret = TEST_FAILED;
9989                 goto on_err;
9990         }
9991
9992         /* Setup CRC operation parameters */
9993         crc_len = d_td->plaintext.no_crc == false ?
9994                         (d_td->plaintext.len -
9995                                 d_td->plaintext.crc_offset -
9996                                 RTE_ETHER_CRC_LEN) :
9997                         0;
9998         crc_len = crc_len > 0 ? crc_len : 0;
9999         ut_params->op->sym->auth.data.length = crc_len;
10000         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10001
10002         /* Setup cipher operation parameters */
10003         cipher_len = d_td->plaintext.no_cipher == false ?
10004                         (d_td->plaintext.len -
10005                                 d_td->plaintext.cipher_offset) :
10006                         0;
10007         cipher_len = cipher_len > 0 ? cipher_len : 0;
10008         ut_params->op->sym->cipher.data.length = cipher_len;
10009         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10010
10011         /* Setup cipher IV */
10012         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10013         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10014
10015         /* Attach session to operation */
10016         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10017
10018         /* Set crypto operation mbufs */
10019         ut_params->op->sym->m_src = ut_params->ibuf;
10020         ut_params->op->sym->m_dst = NULL;
10021
10022         /* Process crypto operation */
10023         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10024                         NULL) {
10025                 printf("Test function %s line %u: failed to process crypto op\n",
10026                         __func__, __LINE__);
10027                 ret = TEST_FAILED;
10028                 goto on_err;
10029         }
10030
10031         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10032                 printf("Test function %s line %u: crypto op processing failed\n",
10033                         __func__, __LINE__);
10034                 ret = TEST_FAILED;
10035                 goto on_err;
10036         }
10037
10038         /* Validate ciphertext */
10039         ciphertext = plaintext;
10040
10041         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10042                 printf("Test function %s line %u: plaintext not as expected\n",
10043                         __func__, __LINE__);
10044                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10045                                 d_td->ciphertext.len);
10046                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10047                 ret = TEST_FAILED;
10048                 goto on_err;
10049         }
10050
10051 on_err:
10052         rte_crypto_op_free(ut_params->op);
10053         ut_params->op = NULL;
10054
10055         if (ut_params->sec_session)
10056                 rte_security_session_destroy(ctx, ut_params->sec_session);
10057         ut_params->sec_session = NULL;
10058
10059         rte_pktmbuf_free(ut_params->ibuf);
10060         ut_params->ibuf = NULL;
10061
10062         return ret;
10063 }
10064 #endif
10065
10066 static int
10067 test_AES_GCM_authenticated_encryption_test_case_1(void)
10068 {
10069         return test_authenticated_encryption(&gcm_test_case_1);
10070 }
10071
10072 static int
10073 test_AES_GCM_authenticated_encryption_test_case_2(void)
10074 {
10075         return test_authenticated_encryption(&gcm_test_case_2);
10076 }
10077
10078 static int
10079 test_AES_GCM_authenticated_encryption_test_case_3(void)
10080 {
10081         return test_authenticated_encryption(&gcm_test_case_3);
10082 }
10083
10084 static int
10085 test_AES_GCM_authenticated_encryption_test_case_4(void)
10086 {
10087         return test_authenticated_encryption(&gcm_test_case_4);
10088 }
10089
10090 static int
10091 test_AES_GCM_authenticated_encryption_test_case_5(void)
10092 {
10093         return test_authenticated_encryption(&gcm_test_case_5);
10094 }
10095
10096 static int
10097 test_AES_GCM_authenticated_encryption_test_case_6(void)
10098 {
10099         return test_authenticated_encryption(&gcm_test_case_6);
10100 }
10101
10102 static int
10103 test_AES_GCM_authenticated_encryption_test_case_7(void)
10104 {
10105         return test_authenticated_encryption(&gcm_test_case_7);
10106 }
10107
10108 static int
10109 test_AES_GCM_authenticated_encryption_test_case_8(void)
10110 {
10111         return test_authenticated_encryption(&gcm_test_case_8);
10112 }
10113
10114 static int
10115 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10116 {
10117         return test_authenticated_encryption(&gcm_J0_test_case_1);
10118 }
10119
10120 static int
10121 test_AES_GCM_auth_encryption_test_case_192_1(void)
10122 {
10123         return test_authenticated_encryption(&gcm_test_case_192_1);
10124 }
10125
10126 static int
10127 test_AES_GCM_auth_encryption_test_case_192_2(void)
10128 {
10129         return test_authenticated_encryption(&gcm_test_case_192_2);
10130 }
10131
10132 static int
10133 test_AES_GCM_auth_encryption_test_case_192_3(void)
10134 {
10135         return test_authenticated_encryption(&gcm_test_case_192_3);
10136 }
10137
10138 static int
10139 test_AES_GCM_auth_encryption_test_case_192_4(void)
10140 {
10141         return test_authenticated_encryption(&gcm_test_case_192_4);
10142 }
10143
10144 static int
10145 test_AES_GCM_auth_encryption_test_case_192_5(void)
10146 {
10147         return test_authenticated_encryption(&gcm_test_case_192_5);
10148 }
10149
10150 static int
10151 test_AES_GCM_auth_encryption_test_case_192_6(void)
10152 {
10153         return test_authenticated_encryption(&gcm_test_case_192_6);
10154 }
10155
10156 static int
10157 test_AES_GCM_auth_encryption_test_case_192_7(void)
10158 {
10159         return test_authenticated_encryption(&gcm_test_case_192_7);
10160 }
10161
10162 static int
10163 test_AES_GCM_auth_encryption_test_case_256_1(void)
10164 {
10165         return test_authenticated_encryption(&gcm_test_case_256_1);
10166 }
10167
10168 static int
10169 test_AES_GCM_auth_encryption_test_case_256_2(void)
10170 {
10171         return test_authenticated_encryption(&gcm_test_case_256_2);
10172 }
10173
10174 static int
10175 test_AES_GCM_auth_encryption_test_case_256_3(void)
10176 {
10177         return test_authenticated_encryption(&gcm_test_case_256_3);
10178 }
10179
10180 static int
10181 test_AES_GCM_auth_encryption_test_case_256_4(void)
10182 {
10183         return test_authenticated_encryption(&gcm_test_case_256_4);
10184 }
10185
10186 static int
10187 test_AES_GCM_auth_encryption_test_case_256_5(void)
10188 {
10189         return test_authenticated_encryption(&gcm_test_case_256_5);
10190 }
10191
10192 static int
10193 test_AES_GCM_auth_encryption_test_case_256_6(void)
10194 {
10195         return test_authenticated_encryption(&gcm_test_case_256_6);
10196 }
10197
10198 static int
10199 test_AES_GCM_auth_encryption_test_case_256_7(void)
10200 {
10201         return test_authenticated_encryption(&gcm_test_case_256_7);
10202 }
10203
10204 static int
10205 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10206 {
10207         return test_authenticated_encryption(&gcm_test_case_aad_1);
10208 }
10209
10210 static int
10211 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10212 {
10213         return test_authenticated_encryption(&gcm_test_case_aad_2);
10214 }
10215
10216 static int
10217 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10218 {
10219         struct aead_test_data tdata;
10220         int res;
10221
10222         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10223         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10224         tdata.iv.data[0] += 1;
10225         res = test_authenticated_encryption(&tdata);
10226         if (res == TEST_SKIPPED)
10227                 return res;
10228         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10229         return TEST_SUCCESS;
10230 }
10231
10232 static int
10233 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10234 {
10235         struct aead_test_data tdata;
10236         int res;
10237
10238         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10239         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10240         tdata.plaintext.data[0] += 1;
10241         res = test_authenticated_encryption(&tdata);
10242         if (res == TEST_SKIPPED)
10243                 return res;
10244         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10245         return TEST_SUCCESS;
10246 }
10247
10248 static int
10249 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10250 {
10251         struct aead_test_data tdata;
10252         int res;
10253
10254         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10255         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10256         tdata.ciphertext.data[0] += 1;
10257         res = test_authenticated_encryption(&tdata);
10258         if (res == TEST_SKIPPED)
10259                 return res;
10260         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10261         return TEST_SUCCESS;
10262 }
10263
10264 static int
10265 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10266 {
10267         struct aead_test_data tdata;
10268         int res;
10269
10270         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10271         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10272         tdata.aad.len += 1;
10273         res = test_authenticated_encryption(&tdata);
10274         if (res == TEST_SKIPPED)
10275                 return res;
10276         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10277         return TEST_SUCCESS;
10278 }
10279
10280 static int
10281 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10282 {
10283         struct aead_test_data tdata;
10284         uint8_t aad[gcm_test_case_7.aad.len];
10285         int res;
10286
10287         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10288         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10289         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10290         aad[0] += 1;
10291         tdata.aad.data = aad;
10292         res = test_authenticated_encryption(&tdata);
10293         if (res == TEST_SKIPPED)
10294                 return res;
10295         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10296         return TEST_SUCCESS;
10297 }
10298
10299 static int
10300 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10301 {
10302         struct aead_test_data tdata;
10303         int res;
10304
10305         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10306         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10307         tdata.auth_tag.data[0] += 1;
10308         res = test_authenticated_encryption(&tdata);
10309         if (res == TEST_SKIPPED)
10310                 return res;
10311         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10312         return TEST_SUCCESS;
10313 }
10314
10315 static int
10316 test_authenticated_decryption(const struct aead_test_data *tdata)
10317 {
10318         struct crypto_testsuite_params *ts_params = &testsuite_params;
10319         struct crypto_unittest_params *ut_params = &unittest_params;
10320
10321         int retval;
10322         uint8_t *plaintext;
10323         uint32_t i;
10324         struct rte_cryptodev_info dev_info;
10325
10326         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10327         uint64_t feat_flags = dev_info.feature_flags;
10328
10329         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10330                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10331                 printf("Device doesn't support RAW data-path APIs.\n");
10332                 return TEST_SKIPPED;
10333         }
10334
10335         /* Verify the capabilities */
10336         struct rte_cryptodev_sym_capability_idx cap_idx;
10337         const struct rte_cryptodev_symmetric_capability *capability;
10338         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10339         cap_idx.algo.aead = tdata->algo;
10340         capability = rte_cryptodev_sym_capability_get(
10341                         ts_params->valid_devs[0], &cap_idx);
10342         if (capability == NULL)
10343                 return TEST_SKIPPED;
10344         if (rte_cryptodev_sym_capability_check_aead(
10345                         capability, tdata->key.len, tdata->auth_tag.len,
10346                         tdata->aad.len, tdata->iv.len))
10347                 return TEST_SKIPPED;
10348
10349         /* Create AEAD session */
10350         retval = create_aead_session(ts_params->valid_devs[0],
10351                         tdata->algo,
10352                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10353                         tdata->key.data, tdata->key.len,
10354                         tdata->aad.len, tdata->auth_tag.len,
10355                         tdata->iv.len);
10356         if (retval < 0)
10357                 return retval;
10358
10359         /* alloc mbuf and set payload */
10360         if (tdata->aad.len > MBUF_SIZE) {
10361                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10362                 /* Populate full size of add data */
10363                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10364                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10365         } else
10366                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10367
10368         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10369                         rte_pktmbuf_tailroom(ut_params->ibuf));
10370
10371         /* Create AEAD operation */
10372         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10373         if (retval < 0)
10374                 return retval;
10375
10376         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10377
10378         ut_params->op->sym->m_src = ut_params->ibuf;
10379
10380         /* Process crypto operation */
10381         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10382                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10383         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10384                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10385                                 ut_params->op, 0, 0, 0, 0);
10386         else
10387                 TEST_ASSERT_NOT_NULL(
10388                         process_crypto_request(ts_params->valid_devs[0],
10389                         ut_params->op), "failed to process sym crypto op");
10390
10391         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10392                         "crypto op processing failed");
10393
10394         if (ut_params->op->sym->m_dst)
10395                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10396                                 uint8_t *);
10397         else
10398                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10399                                 uint8_t *,
10400                                 ut_params->op->sym->cipher.data.offset);
10401
10402         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10403
10404         /* Validate obuf */
10405         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10406                         plaintext,
10407                         tdata->plaintext.data,
10408                         tdata->plaintext.len,
10409                         "Plaintext data not as expected");
10410
10411         TEST_ASSERT_EQUAL(ut_params->op->status,
10412                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10413                         "Authentication failed");
10414
10415         return 0;
10416 }
10417
10418 static int
10419 test_AES_GCM_authenticated_decryption_test_case_1(void)
10420 {
10421         return test_authenticated_decryption(&gcm_test_case_1);
10422 }
10423
10424 static int
10425 test_AES_GCM_authenticated_decryption_test_case_2(void)
10426 {
10427         return test_authenticated_decryption(&gcm_test_case_2);
10428 }
10429
10430 static int
10431 test_AES_GCM_authenticated_decryption_test_case_3(void)
10432 {
10433         return test_authenticated_decryption(&gcm_test_case_3);
10434 }
10435
10436 static int
10437 test_AES_GCM_authenticated_decryption_test_case_4(void)
10438 {
10439         return test_authenticated_decryption(&gcm_test_case_4);
10440 }
10441
10442 static int
10443 test_AES_GCM_authenticated_decryption_test_case_5(void)
10444 {
10445         return test_authenticated_decryption(&gcm_test_case_5);
10446 }
10447
10448 static int
10449 test_AES_GCM_authenticated_decryption_test_case_6(void)
10450 {
10451         return test_authenticated_decryption(&gcm_test_case_6);
10452 }
10453
10454 static int
10455 test_AES_GCM_authenticated_decryption_test_case_7(void)
10456 {
10457         return test_authenticated_decryption(&gcm_test_case_7);
10458 }
10459
10460 static int
10461 test_AES_GCM_authenticated_decryption_test_case_8(void)
10462 {
10463         return test_authenticated_decryption(&gcm_test_case_8);
10464 }
10465
10466 static int
10467 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10468 {
10469         return test_authenticated_decryption(&gcm_J0_test_case_1);
10470 }
10471
10472 static int
10473 test_AES_GCM_auth_decryption_test_case_192_1(void)
10474 {
10475         return test_authenticated_decryption(&gcm_test_case_192_1);
10476 }
10477
10478 static int
10479 test_AES_GCM_auth_decryption_test_case_192_2(void)
10480 {
10481         return test_authenticated_decryption(&gcm_test_case_192_2);
10482 }
10483
10484 static int
10485 test_AES_GCM_auth_decryption_test_case_192_3(void)
10486 {
10487         return test_authenticated_decryption(&gcm_test_case_192_3);
10488 }
10489
10490 static int
10491 test_AES_GCM_auth_decryption_test_case_192_4(void)
10492 {
10493         return test_authenticated_decryption(&gcm_test_case_192_4);
10494 }
10495
10496 static int
10497 test_AES_GCM_auth_decryption_test_case_192_5(void)
10498 {
10499         return test_authenticated_decryption(&gcm_test_case_192_5);
10500 }
10501
10502 static int
10503 test_AES_GCM_auth_decryption_test_case_192_6(void)
10504 {
10505         return test_authenticated_decryption(&gcm_test_case_192_6);
10506 }
10507
10508 static int
10509 test_AES_GCM_auth_decryption_test_case_192_7(void)
10510 {
10511         return test_authenticated_decryption(&gcm_test_case_192_7);
10512 }
10513
10514 static int
10515 test_AES_GCM_auth_decryption_test_case_256_1(void)
10516 {
10517         return test_authenticated_decryption(&gcm_test_case_256_1);
10518 }
10519
10520 static int
10521 test_AES_GCM_auth_decryption_test_case_256_2(void)
10522 {
10523         return test_authenticated_decryption(&gcm_test_case_256_2);
10524 }
10525
10526 static int
10527 test_AES_GCM_auth_decryption_test_case_256_3(void)
10528 {
10529         return test_authenticated_decryption(&gcm_test_case_256_3);
10530 }
10531
10532 static int
10533 test_AES_GCM_auth_decryption_test_case_256_4(void)
10534 {
10535         return test_authenticated_decryption(&gcm_test_case_256_4);
10536 }
10537
10538 static int
10539 test_AES_GCM_auth_decryption_test_case_256_5(void)
10540 {
10541         return test_authenticated_decryption(&gcm_test_case_256_5);
10542 }
10543
10544 static int
10545 test_AES_GCM_auth_decryption_test_case_256_6(void)
10546 {
10547         return test_authenticated_decryption(&gcm_test_case_256_6);
10548 }
10549
10550 static int
10551 test_AES_GCM_auth_decryption_test_case_256_7(void)
10552 {
10553         return test_authenticated_decryption(&gcm_test_case_256_7);
10554 }
10555
10556 static int
10557 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10558 {
10559         return test_authenticated_decryption(&gcm_test_case_aad_1);
10560 }
10561
10562 static int
10563 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10564 {
10565         return test_authenticated_decryption(&gcm_test_case_aad_2);
10566 }
10567
10568 static int
10569 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10570 {
10571         struct aead_test_data tdata;
10572         int res;
10573
10574         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10575         tdata.iv.data[0] += 1;
10576         res = test_authenticated_decryption(&tdata);
10577         if (res == TEST_SKIPPED)
10578                 return res;
10579         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10580         return TEST_SUCCESS;
10581 }
10582
10583 static int
10584 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10585 {
10586         struct aead_test_data tdata;
10587         int res;
10588
10589         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10590         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10591         tdata.plaintext.data[0] += 1;
10592         res = test_authenticated_decryption(&tdata);
10593         if (res == TEST_SKIPPED)
10594                 return res;
10595         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10596         return TEST_SUCCESS;
10597 }
10598
10599 static int
10600 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10601 {
10602         struct aead_test_data tdata;
10603         int res;
10604
10605         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10606         tdata.ciphertext.data[0] += 1;
10607         res = test_authenticated_decryption(&tdata);
10608         if (res == TEST_SKIPPED)
10609                 return res;
10610         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10611         return TEST_SUCCESS;
10612 }
10613
10614 static int
10615 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10616 {
10617         struct aead_test_data tdata;
10618         int res;
10619
10620         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10621         tdata.aad.len += 1;
10622         res = test_authenticated_decryption(&tdata);
10623         if (res == TEST_SKIPPED)
10624                 return res;
10625         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10626         return TEST_SUCCESS;
10627 }
10628
10629 static int
10630 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10631 {
10632         struct aead_test_data tdata;
10633         uint8_t aad[gcm_test_case_7.aad.len];
10634         int res;
10635
10636         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10637         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10638         aad[0] += 1;
10639         tdata.aad.data = aad;
10640         res = test_authenticated_decryption(&tdata);
10641         if (res == TEST_SKIPPED)
10642                 return res;
10643         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10644         return TEST_SUCCESS;
10645 }
10646
10647 static int
10648 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10649 {
10650         struct aead_test_data tdata;
10651         int res;
10652
10653         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10654         tdata.auth_tag.data[0] += 1;
10655         res = test_authenticated_decryption(&tdata);
10656         if (res == TEST_SKIPPED)
10657                 return res;
10658         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10659         return TEST_SUCCESS;
10660 }
10661
10662 static int
10663 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10664 {
10665         struct crypto_testsuite_params *ts_params = &testsuite_params;
10666         struct crypto_unittest_params *ut_params = &unittest_params;
10667
10668         int retval;
10669         uint8_t *ciphertext, *auth_tag;
10670         uint16_t plaintext_pad_len;
10671         struct rte_cryptodev_info dev_info;
10672
10673         /* Verify the capabilities */
10674         struct rte_cryptodev_sym_capability_idx cap_idx;
10675         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10676         cap_idx.algo.aead = tdata->algo;
10677         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10678                         &cap_idx) == NULL)
10679                 return TEST_SKIPPED;
10680
10681         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10682         uint64_t feat_flags = dev_info.feature_flags;
10683
10684         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10685                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10686                 return TEST_SKIPPED;
10687
10688         /* not supported with CPU crypto */
10689         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10690                 return TEST_SKIPPED;
10691
10692         /* Create AEAD session */
10693         retval = create_aead_session(ts_params->valid_devs[0],
10694                         tdata->algo,
10695                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10696                         tdata->key.data, tdata->key.len,
10697                         tdata->aad.len, tdata->auth_tag.len,
10698                         tdata->iv.len);
10699         if (retval < 0)
10700                 return retval;
10701
10702         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10703         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10704
10705         /* clear mbuf payload */
10706         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10707                         rte_pktmbuf_tailroom(ut_params->ibuf));
10708         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10709                         rte_pktmbuf_tailroom(ut_params->obuf));
10710
10711         /* Create AEAD operation */
10712         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10713         if (retval < 0)
10714                 return retval;
10715
10716         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10717
10718         ut_params->op->sym->m_src = ut_params->ibuf;
10719         ut_params->op->sym->m_dst = ut_params->obuf;
10720
10721         /* Process crypto operation */
10722         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10723                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10724                         ut_params->op, 0, 0, 0, 0);
10725         else
10726                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10727                         ut_params->op), "failed to process sym crypto op");
10728
10729         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10730                         "crypto op processing failed");
10731
10732         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10733
10734         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10735                         ut_params->op->sym->cipher.data.offset);
10736         auth_tag = ciphertext + plaintext_pad_len;
10737
10738         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10739         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10740
10741         /* Validate obuf */
10742         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10743                         ciphertext,
10744                         tdata->ciphertext.data,
10745                         tdata->ciphertext.len,
10746                         "Ciphertext data not as expected");
10747
10748         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10749                         auth_tag,
10750                         tdata->auth_tag.data,
10751                         tdata->auth_tag.len,
10752                         "Generated auth tag not as expected");
10753
10754         return 0;
10755
10756 }
10757
10758 static int
10759 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
10760 {
10761         return test_authenticated_encryption_oop(&gcm_test_case_5);
10762 }
10763
10764 static int
10765 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
10766 {
10767         struct crypto_testsuite_params *ts_params = &testsuite_params;
10768         struct crypto_unittest_params *ut_params = &unittest_params;
10769
10770         int retval;
10771         uint8_t *plaintext;
10772         struct rte_cryptodev_info dev_info;
10773
10774         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10775         uint64_t feat_flags = dev_info.feature_flags;
10776
10777         /* Verify the capabilities */
10778         struct rte_cryptodev_sym_capability_idx cap_idx;
10779         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10780         cap_idx.algo.aead = tdata->algo;
10781         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10782                         &cap_idx) == NULL)
10783                 return TEST_SKIPPED;
10784
10785         /* not supported with CPU crypto and raw data-path APIs*/
10786         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
10787                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
10788                 return TEST_SKIPPED;
10789
10790         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10791                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10792                 printf("Device does not support RAW data-path APIs.\n");
10793                 return TEST_SKIPPED;
10794         }
10795
10796         /* Create AEAD session */
10797         retval = create_aead_session(ts_params->valid_devs[0],
10798                         tdata->algo,
10799                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10800                         tdata->key.data, tdata->key.len,
10801                         tdata->aad.len, tdata->auth_tag.len,
10802                         tdata->iv.len);
10803         if (retval < 0)
10804                 return retval;
10805
10806         /* alloc mbuf and set payload */
10807         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10808         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10809
10810         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10811                         rte_pktmbuf_tailroom(ut_params->ibuf));
10812         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10813                         rte_pktmbuf_tailroom(ut_params->obuf));
10814
10815         /* Create AEAD operation */
10816         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10817         if (retval < 0)
10818                 return retval;
10819
10820         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10821
10822         ut_params->op->sym->m_src = ut_params->ibuf;
10823         ut_params->op->sym->m_dst = ut_params->obuf;
10824
10825         /* Process crypto operation */
10826         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10827                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10828                                 ut_params->op, 0, 0, 0, 0);
10829         else
10830                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10831                         ut_params->op), "failed to process sym crypto op");
10832
10833         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10834                         "crypto op processing failed");
10835
10836         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10837                         ut_params->op->sym->cipher.data.offset);
10838
10839         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10840
10841         /* Validate obuf */
10842         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10843                         plaintext,
10844                         tdata->plaintext.data,
10845                         tdata->plaintext.len,
10846                         "Plaintext data not as expected");
10847
10848         TEST_ASSERT_EQUAL(ut_params->op->status,
10849                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10850                         "Authentication failed");
10851         return 0;
10852 }
10853
10854 static int
10855 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
10856 {
10857         return test_authenticated_decryption_oop(&gcm_test_case_5);
10858 }
10859
10860 static int
10861 test_authenticated_encryption_sessionless(
10862                 const struct aead_test_data *tdata)
10863 {
10864         struct crypto_testsuite_params *ts_params = &testsuite_params;
10865         struct crypto_unittest_params *ut_params = &unittest_params;
10866
10867         int retval;
10868         uint8_t *ciphertext, *auth_tag;
10869         uint16_t plaintext_pad_len;
10870         uint8_t key[tdata->key.len + 1];
10871         struct rte_cryptodev_info dev_info;
10872
10873         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10874         uint64_t feat_flags = dev_info.feature_flags;
10875
10876         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10877                 printf("Device doesn't support Sessionless ops.\n");
10878                 return TEST_SKIPPED;
10879         }
10880
10881         /* not supported with CPU crypto */
10882         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10883                 return TEST_SKIPPED;
10884
10885         /* Verify the capabilities */
10886         struct rte_cryptodev_sym_capability_idx cap_idx;
10887         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10888         cap_idx.algo.aead = tdata->algo;
10889         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10890                         &cap_idx) == NULL)
10891                 return TEST_SKIPPED;
10892
10893         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10894
10895         /* clear mbuf payload */
10896         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10897                         rte_pktmbuf_tailroom(ut_params->ibuf));
10898
10899         /* Create AEAD operation */
10900         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10901         if (retval < 0)
10902                 return retval;
10903
10904         /* Create GCM xform */
10905         memcpy(key, tdata->key.data, tdata->key.len);
10906         retval = create_aead_xform(ut_params->op,
10907                         tdata->algo,
10908                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10909                         key, tdata->key.len,
10910                         tdata->aad.len, tdata->auth_tag.len,
10911                         tdata->iv.len);
10912         if (retval < 0)
10913                 return retval;
10914
10915         ut_params->op->sym->m_src = ut_params->ibuf;
10916
10917         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
10918                         RTE_CRYPTO_OP_SESSIONLESS,
10919                         "crypto op session type not sessionless");
10920
10921         /* Process crypto operation */
10922         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10923                         ut_params->op), "failed to process sym crypto op");
10924
10925         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
10926
10927         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10928                         "crypto op status not success");
10929
10930         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10931
10932         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
10933                         ut_params->op->sym->cipher.data.offset);
10934         auth_tag = ciphertext + plaintext_pad_len;
10935
10936         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10937         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10938
10939         /* Validate obuf */
10940         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10941                         ciphertext,
10942                         tdata->ciphertext.data,
10943                         tdata->ciphertext.len,
10944                         "Ciphertext data not as expected");
10945
10946         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10947                         auth_tag,
10948                         tdata->auth_tag.data,
10949                         tdata->auth_tag.len,
10950                         "Generated auth tag not as expected");
10951
10952         return 0;
10953
10954 }
10955
10956 static int
10957 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
10958 {
10959         return test_authenticated_encryption_sessionless(
10960                         &gcm_test_case_5);
10961 }
10962
10963 static int
10964 test_authenticated_decryption_sessionless(
10965                 const struct aead_test_data *tdata)
10966 {
10967         struct crypto_testsuite_params *ts_params = &testsuite_params;
10968         struct crypto_unittest_params *ut_params = &unittest_params;
10969
10970         int retval;
10971         uint8_t *plaintext;
10972         uint8_t key[tdata->key.len + 1];
10973         struct rte_cryptodev_info dev_info;
10974
10975         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10976         uint64_t feat_flags = dev_info.feature_flags;
10977
10978         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
10979                 printf("Device doesn't support Sessionless ops.\n");
10980                 return TEST_SKIPPED;
10981         }
10982
10983         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10984                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10985                 printf("Device doesn't support RAW data-path APIs.\n");
10986                 return TEST_SKIPPED;
10987         }
10988
10989         /* not supported with CPU crypto */
10990         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10991                 return TEST_SKIPPED;
10992
10993         /* Verify the capabilities */
10994         struct rte_cryptodev_sym_capability_idx cap_idx;
10995         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10996         cap_idx.algo.aead = tdata->algo;
10997         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10998                         &cap_idx) == NULL)
10999                 return TEST_SKIPPED;
11000
11001         /* alloc mbuf and set payload */
11002         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11003
11004         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11005                         rte_pktmbuf_tailroom(ut_params->ibuf));
11006
11007         /* Create AEAD operation */
11008         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11009         if (retval < 0)
11010                 return retval;
11011
11012         /* Create AEAD xform */
11013         memcpy(key, tdata->key.data, tdata->key.len);
11014         retval = create_aead_xform(ut_params->op,
11015                         tdata->algo,
11016                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11017                         key, tdata->key.len,
11018                         tdata->aad.len, tdata->auth_tag.len,
11019                         tdata->iv.len);
11020         if (retval < 0)
11021                 return retval;
11022
11023         ut_params->op->sym->m_src = ut_params->ibuf;
11024
11025         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11026                         RTE_CRYPTO_OP_SESSIONLESS,
11027                         "crypto op session type not sessionless");
11028
11029         /* Process crypto operation */
11030         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11031                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11032                                 ut_params->op, 0, 0, 0, 0);
11033         else
11034                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11035                         ts_params->valid_devs[0], ut_params->op),
11036                                 "failed to process sym crypto op");
11037
11038         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11039
11040         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11041                         "crypto op status not success");
11042
11043         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11044                         ut_params->op->sym->cipher.data.offset);
11045
11046         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11047
11048         /* Validate obuf */
11049         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11050                         plaintext,
11051                         tdata->plaintext.data,
11052                         tdata->plaintext.len,
11053                         "Plaintext data not as expected");
11054
11055         TEST_ASSERT_EQUAL(ut_params->op->status,
11056                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11057                         "Authentication failed");
11058         return 0;
11059 }
11060
11061 static int
11062 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11063 {
11064         return test_authenticated_decryption_sessionless(
11065                         &gcm_test_case_5);
11066 }
11067
11068 static int
11069 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11070 {
11071         return test_authenticated_encryption(&ccm_test_case_128_1);
11072 }
11073
11074 static int
11075 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11076 {
11077         return test_authenticated_encryption(&ccm_test_case_128_2);
11078 }
11079
11080 static int
11081 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11082 {
11083         return test_authenticated_encryption(&ccm_test_case_128_3);
11084 }
11085
11086 static int
11087 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11088 {
11089         return test_authenticated_decryption(&ccm_test_case_128_1);
11090 }
11091
11092 static int
11093 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11094 {
11095         return test_authenticated_decryption(&ccm_test_case_128_2);
11096 }
11097
11098 static int
11099 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11100 {
11101         return test_authenticated_decryption(&ccm_test_case_128_3);
11102 }
11103
11104 static int
11105 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11106 {
11107         return test_authenticated_encryption(&ccm_test_case_192_1);
11108 }
11109
11110 static int
11111 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11112 {
11113         return test_authenticated_encryption(&ccm_test_case_192_2);
11114 }
11115
11116 static int
11117 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11118 {
11119         return test_authenticated_encryption(&ccm_test_case_192_3);
11120 }
11121
11122 static int
11123 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11124 {
11125         return test_authenticated_decryption(&ccm_test_case_192_1);
11126 }
11127
11128 static int
11129 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11130 {
11131         return test_authenticated_decryption(&ccm_test_case_192_2);
11132 }
11133
11134 static int
11135 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11136 {
11137         return test_authenticated_decryption(&ccm_test_case_192_3);
11138 }
11139
11140 static int
11141 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11142 {
11143         return test_authenticated_encryption(&ccm_test_case_256_1);
11144 }
11145
11146 static int
11147 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11148 {
11149         return test_authenticated_encryption(&ccm_test_case_256_2);
11150 }
11151
11152 static int
11153 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11154 {
11155         return test_authenticated_encryption(&ccm_test_case_256_3);
11156 }
11157
11158 static int
11159 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11160 {
11161         return test_authenticated_decryption(&ccm_test_case_256_1);
11162 }
11163
11164 static int
11165 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11166 {
11167         return test_authenticated_decryption(&ccm_test_case_256_2);
11168 }
11169
11170 static int
11171 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11172 {
11173         return test_authenticated_decryption(&ccm_test_case_256_3);
11174 }
11175
11176 static int
11177 test_stats(void)
11178 {
11179         struct crypto_testsuite_params *ts_params = &testsuite_params;
11180         struct rte_cryptodev_stats stats;
11181
11182         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11183                 return TEST_SKIPPED;
11184
11185         /* Verify the capabilities */
11186         struct rte_cryptodev_sym_capability_idx cap_idx;
11187         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11188         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11189         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11190                         &cap_idx) == NULL)
11191                 return TEST_SKIPPED;
11192         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11193         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11194         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11195                         &cap_idx) == NULL)
11196                 return TEST_SKIPPED;
11197
11198         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11199                         == -ENOTSUP)
11200                 return TEST_SKIPPED;
11201
11202         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11203         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11204                         &stats) == -ENODEV),
11205                 "rte_cryptodev_stats_get invalid dev failed");
11206         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11207                 "rte_cryptodev_stats_get invalid Param failed");
11208
11209         /* Test expected values */
11210         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11211         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11212                         &stats),
11213                 "rte_cryptodev_stats_get failed");
11214         TEST_ASSERT((stats.enqueued_count == 1),
11215                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11216         TEST_ASSERT((stats.dequeued_count == 1),
11217                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11218         TEST_ASSERT((stats.enqueue_err_count == 0),
11219                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11220         TEST_ASSERT((stats.dequeue_err_count == 0),
11221                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11222
11223         /* invalid device but should ignore and not reset device stats*/
11224         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11225         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11226                         &stats),
11227                 "rte_cryptodev_stats_get failed");
11228         TEST_ASSERT((stats.enqueued_count == 1),
11229                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11230
11231         /* check that a valid reset clears stats */
11232         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11233         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11234                         &stats),
11235                                           "rte_cryptodev_stats_get failed");
11236         TEST_ASSERT((stats.enqueued_count == 0),
11237                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11238         TEST_ASSERT((stats.dequeued_count == 0),
11239                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11240
11241         return TEST_SUCCESS;
11242 }
11243
11244 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11245                                    struct crypto_unittest_params *ut_params,
11246                                    enum rte_crypto_auth_operation op,
11247                                    const struct HMAC_MD5_vector *test_case)
11248 {
11249         uint8_t key[64];
11250         int status;
11251
11252         memcpy(key, test_case->key.data, test_case->key.len);
11253
11254         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11255         ut_params->auth_xform.next = NULL;
11256         ut_params->auth_xform.auth.op = op;
11257
11258         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11259
11260         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11261         ut_params->auth_xform.auth.key.length = test_case->key.len;
11262         ut_params->auth_xform.auth.key.data = key;
11263
11264         ut_params->sess = rte_cryptodev_sym_session_create(
11265                         ts_params->session_mpool);
11266         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11267         if (ut_params->sess == NULL)
11268                 return TEST_FAILED;
11269
11270         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11271                         ut_params->sess, &ut_params->auth_xform,
11272                         ts_params->session_priv_mpool);
11273         if (status == -ENOTSUP)
11274                 return TEST_SKIPPED;
11275
11276         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11277
11278         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11279                         rte_pktmbuf_tailroom(ut_params->ibuf));
11280
11281         return 0;
11282 }
11283
11284 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11285                               const struct HMAC_MD5_vector *test_case,
11286                               uint8_t **plaintext)
11287 {
11288         uint16_t plaintext_pad_len;
11289
11290         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11291
11292         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11293                                 16);
11294
11295         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11296                         plaintext_pad_len);
11297         memcpy(*plaintext, test_case->plaintext.data,
11298                         test_case->plaintext.len);
11299
11300         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11301                         ut_params->ibuf, MD5_DIGEST_LEN);
11302         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11303                         "no room to append digest");
11304         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11305                         ut_params->ibuf, plaintext_pad_len);
11306
11307         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11308                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11309                            test_case->auth_tag.len);
11310         }
11311
11312         sym_op->auth.data.offset = 0;
11313         sym_op->auth.data.length = test_case->plaintext.len;
11314
11315         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11316         ut_params->op->sym->m_src = ut_params->ibuf;
11317
11318         return 0;
11319 }
11320
11321 static int
11322 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11323 {
11324         uint16_t plaintext_pad_len;
11325         uint8_t *plaintext, *auth_tag;
11326
11327         struct crypto_testsuite_params *ts_params = &testsuite_params;
11328         struct crypto_unittest_params *ut_params = &unittest_params;
11329         struct rte_cryptodev_info dev_info;
11330
11331         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11332         uint64_t feat_flags = dev_info.feature_flags;
11333
11334         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11335                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11336                 printf("Device doesn't support RAW data-path APIs.\n");
11337                 return TEST_SKIPPED;
11338         }
11339
11340         /* Verify the capabilities */
11341         struct rte_cryptodev_sym_capability_idx cap_idx;
11342         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11343         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11344         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11345                         &cap_idx) == NULL)
11346                 return TEST_SKIPPED;
11347
11348         if (MD5_HMAC_create_session(ts_params, ut_params,
11349                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11350                 return TEST_FAILED;
11351
11352         /* Generate Crypto op data structure */
11353         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11354                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11355         TEST_ASSERT_NOT_NULL(ut_params->op,
11356                         "Failed to allocate symmetric crypto operation struct");
11357
11358         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11359                                 16);
11360
11361         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11362                 return TEST_FAILED;
11363
11364         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11365                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11366                         ut_params->op);
11367         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11368                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11369                                 ut_params->op, 0, 1, 0, 0);
11370         else
11371                 TEST_ASSERT_NOT_NULL(
11372                         process_crypto_request(ts_params->valid_devs[0],
11373                                 ut_params->op),
11374                                 "failed to process sym crypto op");
11375
11376         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11377                         "crypto op processing failed");
11378
11379         if (ut_params->op->sym->m_dst) {
11380                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11381                                 uint8_t *, plaintext_pad_len);
11382         } else {
11383                 auth_tag = plaintext + plaintext_pad_len;
11384         }
11385
11386         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11387                         auth_tag,
11388                         test_case->auth_tag.data,
11389                         test_case->auth_tag.len,
11390                         "HMAC_MD5 generated tag not as expected");
11391
11392         return TEST_SUCCESS;
11393 }
11394
11395 static int
11396 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11397 {
11398         uint8_t *plaintext;
11399
11400         struct crypto_testsuite_params *ts_params = &testsuite_params;
11401         struct crypto_unittest_params *ut_params = &unittest_params;
11402         struct rte_cryptodev_info dev_info;
11403
11404         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11405         uint64_t feat_flags = dev_info.feature_flags;
11406
11407         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11408                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11409                 printf("Device doesn't support RAW data-path APIs.\n");
11410                 return TEST_SKIPPED;
11411         }
11412
11413         /* Verify the capabilities */
11414         struct rte_cryptodev_sym_capability_idx cap_idx;
11415         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11416         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11417         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11418                         &cap_idx) == NULL)
11419                 return TEST_SKIPPED;
11420
11421         if (MD5_HMAC_create_session(ts_params, ut_params,
11422                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11423                 return TEST_FAILED;
11424         }
11425
11426         /* Generate Crypto op data structure */
11427         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11428                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11429         TEST_ASSERT_NOT_NULL(ut_params->op,
11430                         "Failed to allocate symmetric crypto operation struct");
11431
11432         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11433                 return TEST_FAILED;
11434
11435         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11436                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11437                         ut_params->op);
11438         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11439                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11440                                 ut_params->op, 0, 1, 0, 0);
11441         else
11442                 TEST_ASSERT_NOT_NULL(
11443                         process_crypto_request(ts_params->valid_devs[0],
11444                                 ut_params->op),
11445                                 "failed to process sym crypto op");
11446
11447         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11448                         "HMAC_MD5 crypto op processing failed");
11449
11450         return TEST_SUCCESS;
11451 }
11452
11453 static int
11454 test_MD5_HMAC_generate_case_1(void)
11455 {
11456         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11457 }
11458
11459 static int
11460 test_MD5_HMAC_verify_case_1(void)
11461 {
11462         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11463 }
11464
11465 static int
11466 test_MD5_HMAC_generate_case_2(void)
11467 {
11468         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11469 }
11470
11471 static int
11472 test_MD5_HMAC_verify_case_2(void)
11473 {
11474         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11475 }
11476
11477 static int
11478 test_multi_session(void)
11479 {
11480         struct crypto_testsuite_params *ts_params = &testsuite_params;
11481         struct crypto_unittest_params *ut_params = &unittest_params;
11482
11483         struct rte_cryptodev_info dev_info;
11484         struct rte_cryptodev_sym_session **sessions;
11485
11486         uint16_t i;
11487         int status;
11488
11489         /* Verify the capabilities */
11490         struct rte_cryptodev_sym_capability_idx cap_idx;
11491         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11492         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11493         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11494                         &cap_idx) == NULL)
11495                 return TEST_SKIPPED;
11496         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11497         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11498         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11499                         &cap_idx) == NULL)
11500                 return TEST_SKIPPED;
11501
11502         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11503                         aes_cbc_key, hmac_sha512_key);
11504
11505
11506         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11507
11508         sessions = rte_malloc(NULL,
11509                         sizeof(struct rte_cryptodev_sym_session *) *
11510                         (MAX_NB_SESSIONS + 1), 0);
11511
11512         /* Create multiple crypto sessions*/
11513         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11514
11515                 sessions[i] = rte_cryptodev_sym_session_create(
11516                                 ts_params->session_mpool);
11517                 TEST_ASSERT_NOT_NULL(sessions[i],
11518                                 "Session creation failed at session number %u",
11519                                 i);
11520
11521                 status = rte_cryptodev_sym_session_init(
11522                                 ts_params->valid_devs[0],
11523                                 sessions[i], &ut_params->auth_xform,
11524                                 ts_params->session_priv_mpool);
11525                 if (status == -ENOTSUP)
11526                         return TEST_SKIPPED;
11527
11528                 /* Attempt to send a request on each session */
11529                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11530                         sessions[i],
11531                         ut_params,
11532                         ts_params,
11533                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11534                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11535                         aes_cbc_iv),
11536                         "Failed to perform decrypt on request number %u.", i);
11537                 /* free crypto operation structure */
11538                 if (ut_params->op)
11539                         rte_crypto_op_free(ut_params->op);
11540
11541                 /*
11542                  * free mbuf - both obuf and ibuf are usually the same,
11543                  * so check if they point at the same address is necessary,
11544                  * to avoid freeing the mbuf twice.
11545                  */
11546                 if (ut_params->obuf) {
11547                         rte_pktmbuf_free(ut_params->obuf);
11548                         if (ut_params->ibuf == ut_params->obuf)
11549                                 ut_params->ibuf = 0;
11550                         ut_params->obuf = 0;
11551                 }
11552                 if (ut_params->ibuf) {
11553                         rte_pktmbuf_free(ut_params->ibuf);
11554                         ut_params->ibuf = 0;
11555                 }
11556         }
11557
11558         sessions[i] = NULL;
11559         /* Next session create should fail */
11560         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11561                         sessions[i], &ut_params->auth_xform,
11562                         ts_params->session_priv_mpool);
11563         TEST_ASSERT_NULL(sessions[i],
11564                         "Session creation succeeded unexpectedly!");
11565
11566         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11567                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11568                                 sessions[i]);
11569                 rte_cryptodev_sym_session_free(sessions[i]);
11570         }
11571
11572         rte_free(sessions);
11573
11574         return TEST_SUCCESS;
11575 }
11576
11577 struct multi_session_params {
11578         struct crypto_unittest_params ut_params;
11579         uint8_t *cipher_key;
11580         uint8_t *hmac_key;
11581         const uint8_t *cipher;
11582         const uint8_t *digest;
11583         uint8_t *iv;
11584 };
11585
11586 #define MB_SESSION_NUMBER 3
11587
11588 static int
11589 test_multi_session_random_usage(void)
11590 {
11591         struct crypto_testsuite_params *ts_params = &testsuite_params;
11592         struct rte_cryptodev_info dev_info;
11593         struct rte_cryptodev_sym_session **sessions;
11594         uint32_t i, j;
11595         struct multi_session_params ut_paramz[] = {
11596
11597                 {
11598                         .cipher_key = ms_aes_cbc_key0,
11599                         .hmac_key = ms_hmac_key0,
11600                         .cipher = ms_aes_cbc_cipher0,
11601                         .digest = ms_hmac_digest0,
11602                         .iv = ms_aes_cbc_iv0
11603                 },
11604                 {
11605                         .cipher_key = ms_aes_cbc_key1,
11606                         .hmac_key = ms_hmac_key1,
11607                         .cipher = ms_aes_cbc_cipher1,
11608                         .digest = ms_hmac_digest1,
11609                         .iv = ms_aes_cbc_iv1
11610                 },
11611                 {
11612                         .cipher_key = ms_aes_cbc_key2,
11613                         .hmac_key = ms_hmac_key2,
11614                         .cipher = ms_aes_cbc_cipher2,
11615                         .digest = ms_hmac_digest2,
11616                         .iv = ms_aes_cbc_iv2
11617                 },
11618
11619         };
11620         int status;
11621
11622         /* Verify the capabilities */
11623         struct rte_cryptodev_sym_capability_idx cap_idx;
11624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11625         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11626         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11627                         &cap_idx) == NULL)
11628                 return TEST_SKIPPED;
11629         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11630         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11631         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11632                         &cap_idx) == NULL)
11633                 return TEST_SKIPPED;
11634
11635         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11636
11637         sessions = rte_malloc(NULL,
11638                         (sizeof(struct rte_cryptodev_sym_session *)
11639                                         * MAX_NB_SESSIONS) + 1, 0);
11640
11641         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11642                 sessions[i] = rte_cryptodev_sym_session_create(
11643                                 ts_params->session_mpool);
11644                 TEST_ASSERT_NOT_NULL(sessions[i],
11645                                 "Session creation failed at session number %u",
11646                                 i);
11647
11648                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11649                                 sizeof(struct crypto_unittest_params));
11650
11651                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11652                                 &ut_paramz[i].ut_params,
11653                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11654
11655                 /* Create multiple crypto sessions*/
11656                 status = rte_cryptodev_sym_session_init(
11657                                 ts_params->valid_devs[0],
11658                                 sessions[i],
11659                                 &ut_paramz[i].ut_params.auth_xform,
11660                                 ts_params->session_priv_mpool);
11661
11662                 if (status == -ENOTSUP)
11663                         return TEST_SKIPPED;
11664
11665                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11666         }
11667
11668         srand(time(NULL));
11669         for (i = 0; i < 40000; i++) {
11670
11671                 j = rand() % MB_SESSION_NUMBER;
11672
11673                 TEST_ASSERT_SUCCESS(
11674                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11675                                         sessions[j],
11676                                         &ut_paramz[j].ut_params,
11677                                         ts_params, ut_paramz[j].cipher,
11678                                         ut_paramz[j].digest,
11679                                         ut_paramz[j].iv),
11680                         "Failed to perform decrypt on request number %u.", i);
11681
11682                 if (ut_paramz[j].ut_params.op)
11683                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11684
11685                 /*
11686                  * free mbuf - both obuf and ibuf are usually the same,
11687                  * so check if they point at the same address is necessary,
11688                  * to avoid freeing the mbuf twice.
11689                  */
11690                 if (ut_paramz[j].ut_params.obuf) {
11691                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11692                         if (ut_paramz[j].ut_params.ibuf
11693                                         == ut_paramz[j].ut_params.obuf)
11694                                 ut_paramz[j].ut_params.ibuf = 0;
11695                         ut_paramz[j].ut_params.obuf = 0;
11696                 }
11697                 if (ut_paramz[j].ut_params.ibuf) {
11698                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11699                         ut_paramz[j].ut_params.ibuf = 0;
11700                 }
11701         }
11702
11703         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11704                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11705                                 sessions[i]);
11706                 rte_cryptodev_sym_session_free(sessions[i]);
11707         }
11708
11709         rte_free(sessions);
11710
11711         return TEST_SUCCESS;
11712 }
11713
11714 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11715                         0xab, 0xab, 0xab, 0xab,
11716                         0xab, 0xab, 0xab, 0xab,
11717                         0xab, 0xab, 0xab, 0xab};
11718
11719 static int
11720 test_null_invalid_operation(void)
11721 {
11722         struct crypto_testsuite_params *ts_params = &testsuite_params;
11723         struct crypto_unittest_params *ut_params = &unittest_params;
11724         int ret;
11725
11726         /* This test is for NULL PMD only */
11727         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11728                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11729                 return TEST_SKIPPED;
11730
11731         /* Setup Cipher Parameters */
11732         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11733         ut_params->cipher_xform.next = NULL;
11734
11735         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11736         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11737
11738         ut_params->sess = rte_cryptodev_sym_session_create(
11739                         ts_params->session_mpool);
11740
11741         /* Create Crypto session*/
11742         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11743                         ut_params->sess, &ut_params->cipher_xform,
11744                         ts_params->session_priv_mpool);
11745         TEST_ASSERT(ret < 0,
11746                         "Session creation succeeded unexpectedly");
11747
11748
11749         /* Setup HMAC Parameters */
11750         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11751         ut_params->auth_xform.next = NULL;
11752
11753         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
11754         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11755
11756         ut_params->sess = rte_cryptodev_sym_session_create(
11757                         ts_params->session_mpool);
11758
11759         /* Create Crypto session*/
11760         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11761                         ut_params->sess, &ut_params->auth_xform,
11762                         ts_params->session_priv_mpool);
11763         TEST_ASSERT(ret < 0,
11764                         "Session creation succeeded unexpectedly");
11765
11766         return TEST_SUCCESS;
11767 }
11768
11769
11770 #define NULL_BURST_LENGTH (32)
11771
11772 static int
11773 test_null_burst_operation(void)
11774 {
11775         struct crypto_testsuite_params *ts_params = &testsuite_params;
11776         struct crypto_unittest_params *ut_params = &unittest_params;
11777         int status;
11778
11779         unsigned i, burst_len = NULL_BURST_LENGTH;
11780
11781         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
11782         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
11783
11784         /* This test is for NULL PMD only */
11785         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11786                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11787                 return TEST_SKIPPED;
11788
11789         /* Setup Cipher Parameters */
11790         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11791         ut_params->cipher_xform.next = &ut_params->auth_xform;
11792
11793         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
11794         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11795
11796         /* Setup HMAC Parameters */
11797         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11798         ut_params->auth_xform.next = NULL;
11799
11800         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
11801         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
11802
11803         ut_params->sess = rte_cryptodev_sym_session_create(
11804                         ts_params->session_mpool);
11805         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11806
11807         /* Create Crypto session*/
11808         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11809                         ut_params->sess, &ut_params->cipher_xform,
11810                         ts_params->session_priv_mpool);
11811
11812         if (status == -ENOTSUP)
11813                 return TEST_SKIPPED;
11814
11815         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11816
11817         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
11818                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
11819                         burst_len, "failed to generate burst of crypto ops");
11820
11821         /* Generate an operation for each mbuf in burst */
11822         for (i = 0; i < burst_len; i++) {
11823                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11824
11825                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
11826
11827                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
11828                                 sizeof(unsigned));
11829                 *data = i;
11830
11831                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
11832
11833                 burst[i]->sym->m_src = m;
11834         }
11835
11836         /* Process crypto operation */
11837         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
11838                         0, burst, burst_len),
11839                         burst_len,
11840                         "Error enqueuing burst");
11841
11842         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
11843                         0, burst_dequeued, burst_len),
11844                         burst_len,
11845                         "Error dequeuing burst");
11846
11847
11848         for (i = 0; i < burst_len; i++) {
11849                 TEST_ASSERT_EQUAL(
11850                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
11851                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
11852                                         uint32_t *),
11853                         "data not as expected");
11854
11855                 rte_pktmbuf_free(burst[i]->sym->m_src);
11856                 rte_crypto_op_free(burst[i]);
11857         }
11858
11859         return TEST_SUCCESS;
11860 }
11861
11862 static uint16_t
11863 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11864                   uint16_t nb_ops, void *user_param)
11865 {
11866         RTE_SET_USED(dev_id);
11867         RTE_SET_USED(qp_id);
11868         RTE_SET_USED(ops);
11869         RTE_SET_USED(user_param);
11870
11871         printf("crypto enqueue callback called\n");
11872         return nb_ops;
11873 }
11874
11875 static uint16_t
11876 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
11877                   uint16_t nb_ops, void *user_param)
11878 {
11879         RTE_SET_USED(dev_id);
11880         RTE_SET_USED(qp_id);
11881         RTE_SET_USED(ops);
11882         RTE_SET_USED(user_param);
11883
11884         printf("crypto dequeue callback called\n");
11885         return nb_ops;
11886 }
11887
11888 /*
11889  * Thread using enqueue/dequeue callback with RCU.
11890  */
11891 static int
11892 test_enqdeq_callback_thread(void *arg)
11893 {
11894         RTE_SET_USED(arg);
11895         /* DP thread calls rte_cryptodev_enqueue_burst()/
11896          * rte_cryptodev_dequeue_burst() and invokes callback.
11897          */
11898         test_null_burst_operation();
11899         return 0;
11900 }
11901
11902 static int
11903 test_enq_callback_setup(void)
11904 {
11905         struct crypto_testsuite_params *ts_params = &testsuite_params;
11906         struct rte_cryptodev_info dev_info;
11907         struct rte_cryptodev_qp_conf qp_conf = {
11908                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
11909         };
11910
11911         struct rte_cryptodev_cb *cb;
11912         uint16_t qp_id = 0;
11913
11914         /* Stop the device in case it's started so it can be configured */
11915         rte_cryptodev_stop(ts_params->valid_devs[0]);
11916
11917         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11918
11919         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
11920                         &ts_params->conf),
11921                         "Failed to configure cryptodev %u",
11922                         ts_params->valid_devs[0]);
11923
11924         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
11925         qp_conf.mp_session = ts_params->session_mpool;
11926         qp_conf.mp_session_private = ts_params->session_priv_mpool;
11927
11928         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
11929                         ts_params->valid_devs[0], qp_id, &qp_conf,
11930                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
11931                         "Failed test for "
11932                         "rte_cryptodev_queue_pair_setup: num_inflights "
11933                         "%u on qp %u on cryptodev %u",
11934                         qp_conf.nb_descriptors, qp_id,
11935                         ts_params->valid_devs[0]);
11936
11937         /* Test with invalid crypto device */
11938         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
11939                         qp_id, test_enq_callback, NULL);
11940         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11941                         "cryptodev %u did not fail",
11942                         qp_id, RTE_CRYPTO_MAX_DEVS);
11943
11944         /* Test with invalid queue pair */
11945         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11946                         dev_info.max_nb_queue_pairs + 1,
11947                         test_enq_callback, NULL);
11948         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11949                         "cryptodev %u did not fail",
11950                         dev_info.max_nb_queue_pairs + 1,
11951                         ts_params->valid_devs[0]);
11952
11953         /* Test with NULL callback */
11954         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11955                         qp_id, NULL, NULL);
11956         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
11957                         "cryptodev %u did not fail",
11958                         qp_id, ts_params->valid_devs[0]);
11959
11960         /* Test with valid configuration */
11961         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
11962                         qp_id, test_enq_callback, NULL);
11963         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
11964                         "qp %u on cryptodev %u",
11965                         qp_id, ts_params->valid_devs[0]);
11966
11967         rte_cryptodev_start(ts_params->valid_devs[0]);
11968
11969         /* Launch a thread */
11970         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
11971                                 rte_get_next_lcore(-1, 1, 0));
11972
11973         /* Wait until reader exited. */
11974         rte_eal_mp_wait_lcore();
11975
11976         /* Test with invalid crypto device */
11977         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11978                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
11979                         "Expected call to fail as crypto device is invalid");
11980
11981         /* Test with invalid queue pair */
11982         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11983                         ts_params->valid_devs[0],
11984                         dev_info.max_nb_queue_pairs + 1, cb),
11985                         "Expected call to fail as queue pair is invalid");
11986
11987         /* Test with NULL callback */
11988         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
11989                         ts_params->valid_devs[0], qp_id, NULL),
11990                         "Expected call to fail as callback is NULL");
11991
11992         /* Test with valid configuration */
11993         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
11994                         ts_params->valid_devs[0], qp_id, cb),
11995                         "Failed test to remove callback on "
11996                         "qp %u on cryptodev %u",
11997                         qp_id, ts_params->valid_devs[0]);
11998
11999         return TEST_SUCCESS;
12000 }
12001
12002 static int
12003 test_deq_callback_setup(void)
12004 {
12005         struct crypto_testsuite_params *ts_params = &testsuite_params;
12006         struct rte_cryptodev_info dev_info;
12007         struct rte_cryptodev_qp_conf qp_conf = {
12008                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12009         };
12010
12011         struct rte_cryptodev_cb *cb;
12012         uint16_t qp_id = 0;
12013
12014         /* Stop the device in case it's started so it can be configured */
12015         rte_cryptodev_stop(ts_params->valid_devs[0]);
12016
12017         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12018
12019         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12020                         &ts_params->conf),
12021                         "Failed to configure cryptodev %u",
12022                         ts_params->valid_devs[0]);
12023
12024         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12025         qp_conf.mp_session = ts_params->session_mpool;
12026         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12027
12028         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12029                         ts_params->valid_devs[0], qp_id, &qp_conf,
12030                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12031                         "Failed test for "
12032                         "rte_cryptodev_queue_pair_setup: num_inflights "
12033                         "%u on qp %u on cryptodev %u",
12034                         qp_conf.nb_descriptors, qp_id,
12035                         ts_params->valid_devs[0]);
12036
12037         /* Test with invalid crypto device */
12038         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12039                         qp_id, test_deq_callback, NULL);
12040         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12041                         "cryptodev %u did not fail",
12042                         qp_id, RTE_CRYPTO_MAX_DEVS);
12043
12044         /* Test with invalid queue pair */
12045         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12046                         dev_info.max_nb_queue_pairs + 1,
12047                         test_deq_callback, NULL);
12048         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12049                         "cryptodev %u did not fail",
12050                         dev_info.max_nb_queue_pairs + 1,
12051                         ts_params->valid_devs[0]);
12052
12053         /* Test with NULL callback */
12054         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12055                         qp_id, NULL, NULL);
12056         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12057                         "cryptodev %u did not fail",
12058                         qp_id, ts_params->valid_devs[0]);
12059
12060         /* Test with valid configuration */
12061         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12062                         qp_id, test_deq_callback, NULL);
12063         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12064                         "qp %u on cryptodev %u",
12065                         qp_id, ts_params->valid_devs[0]);
12066
12067         rte_cryptodev_start(ts_params->valid_devs[0]);
12068
12069         /* Launch a thread */
12070         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12071                                 rte_get_next_lcore(-1, 1, 0));
12072
12073         /* Wait until reader exited. */
12074         rte_eal_mp_wait_lcore();
12075
12076         /* Test with invalid crypto device */
12077         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12078                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12079                         "Expected call to fail as crypto device is invalid");
12080
12081         /* Test with invalid queue pair */
12082         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12083                         ts_params->valid_devs[0],
12084                         dev_info.max_nb_queue_pairs + 1, cb),
12085                         "Expected call to fail as queue pair is invalid");
12086
12087         /* Test with NULL callback */
12088         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12089                         ts_params->valid_devs[0], qp_id, NULL),
12090                         "Expected call to fail as callback is NULL");
12091
12092         /* Test with valid configuration */
12093         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12094                         ts_params->valid_devs[0], qp_id, cb),
12095                         "Failed test to remove callback on "
12096                         "qp %u on cryptodev %u",
12097                         qp_id, ts_params->valid_devs[0]);
12098
12099         return TEST_SUCCESS;
12100 }
12101
12102 static void
12103 generate_gmac_large_plaintext(uint8_t *data)
12104 {
12105         uint16_t i;
12106
12107         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12108                 memcpy(&data[i], &data[0], 32);
12109 }
12110
12111 static int
12112 create_gmac_operation(enum rte_crypto_auth_operation op,
12113                 const struct gmac_test_data *tdata)
12114 {
12115         struct crypto_testsuite_params *ts_params = &testsuite_params;
12116         struct crypto_unittest_params *ut_params = &unittest_params;
12117         struct rte_crypto_sym_op *sym_op;
12118
12119         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12120
12121         /* Generate Crypto op data structure */
12122         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12123                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12124         TEST_ASSERT_NOT_NULL(ut_params->op,
12125                         "Failed to allocate symmetric crypto operation struct");
12126
12127         sym_op = ut_params->op->sym;
12128
12129         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12130                         ut_params->ibuf, tdata->gmac_tag.len);
12131         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12132                         "no room to append digest");
12133
12134         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12135                         ut_params->ibuf, plaintext_pad_len);
12136
12137         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12138                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12139                                 tdata->gmac_tag.len);
12140                 debug_hexdump(stdout, "digest:",
12141                                 sym_op->auth.digest.data,
12142                                 tdata->gmac_tag.len);
12143         }
12144
12145         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12146                         uint8_t *, IV_OFFSET);
12147
12148         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12149
12150         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12151
12152         sym_op->cipher.data.length = 0;
12153         sym_op->cipher.data.offset = 0;
12154
12155         sym_op->auth.data.offset = 0;
12156         sym_op->auth.data.length = tdata->plaintext.len;
12157
12158         return 0;
12159 }
12160
12161 static int
12162 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12163                 const struct gmac_test_data *tdata,
12164                 void *digest_mem, uint64_t digest_phys)
12165 {
12166         struct crypto_testsuite_params *ts_params = &testsuite_params;
12167         struct crypto_unittest_params *ut_params = &unittest_params;
12168         struct rte_crypto_sym_op *sym_op;
12169
12170         /* Generate Crypto op data structure */
12171         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12172                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12173         TEST_ASSERT_NOT_NULL(ut_params->op,
12174                         "Failed to allocate symmetric crypto operation struct");
12175
12176         sym_op = ut_params->op->sym;
12177
12178         sym_op->auth.digest.data = digest_mem;
12179         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12180                         "no room to append digest");
12181
12182         sym_op->auth.digest.phys_addr = digest_phys;
12183
12184         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12185                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12186                                 tdata->gmac_tag.len);
12187                 debug_hexdump(stdout, "digest:",
12188                                 sym_op->auth.digest.data,
12189                                 tdata->gmac_tag.len);
12190         }
12191
12192         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12193                         uint8_t *, IV_OFFSET);
12194
12195         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12196
12197         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12198
12199         sym_op->cipher.data.length = 0;
12200         sym_op->cipher.data.offset = 0;
12201
12202         sym_op->auth.data.offset = 0;
12203         sym_op->auth.data.length = tdata->plaintext.len;
12204
12205         return 0;
12206 }
12207
12208 static int create_gmac_session(uint8_t dev_id,
12209                 const struct gmac_test_data *tdata,
12210                 enum rte_crypto_auth_operation auth_op)
12211 {
12212         uint8_t auth_key[tdata->key.len];
12213         int status;
12214
12215         struct crypto_testsuite_params *ts_params = &testsuite_params;
12216         struct crypto_unittest_params *ut_params = &unittest_params;
12217
12218         memcpy(auth_key, tdata->key.data, tdata->key.len);
12219
12220         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12221         ut_params->auth_xform.next = NULL;
12222
12223         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12224         ut_params->auth_xform.auth.op = auth_op;
12225         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12226         ut_params->auth_xform.auth.key.length = tdata->key.len;
12227         ut_params->auth_xform.auth.key.data = auth_key;
12228         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12229         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12230
12231
12232         ut_params->sess = rte_cryptodev_sym_session_create(
12233                         ts_params->session_mpool);
12234         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12235
12236         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12237                         &ut_params->auth_xform,
12238                         ts_params->session_priv_mpool);
12239
12240         return status;
12241 }
12242
12243 static int
12244 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12245 {
12246         struct crypto_testsuite_params *ts_params = &testsuite_params;
12247         struct crypto_unittest_params *ut_params = &unittest_params;
12248         struct rte_cryptodev_info dev_info;
12249
12250         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12251         uint64_t feat_flags = dev_info.feature_flags;
12252
12253         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12254                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12255                 printf("Device doesn't support RAW data-path APIs.\n");
12256                 return TEST_SKIPPED;
12257         }
12258
12259         int retval;
12260
12261         uint8_t *auth_tag, *plaintext;
12262         uint16_t plaintext_pad_len;
12263
12264         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12265                               "No GMAC length in the source data");
12266
12267         /* Verify the capabilities */
12268         struct rte_cryptodev_sym_capability_idx cap_idx;
12269         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12270         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12271         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12272                         &cap_idx) == NULL)
12273                 return TEST_SKIPPED;
12274
12275         retval = create_gmac_session(ts_params->valid_devs[0],
12276                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12277
12278         if (retval == -ENOTSUP)
12279                 return TEST_SKIPPED;
12280         if (retval < 0)
12281                 return retval;
12282
12283         if (tdata->plaintext.len > MBUF_SIZE)
12284                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12285         else
12286                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12287         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12288                         "Failed to allocate input buffer in mempool");
12289
12290         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12291                         rte_pktmbuf_tailroom(ut_params->ibuf));
12292
12293         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12294         /*
12295          * Runtime generate the large plain text instead of use hard code
12296          * plain text vector. It is done to avoid create huge source file
12297          * with the test vector.
12298          */
12299         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12300                 generate_gmac_large_plaintext(tdata->plaintext.data);
12301
12302         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12303                                 plaintext_pad_len);
12304         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12305
12306         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12307         debug_hexdump(stdout, "plaintext:", plaintext,
12308                         tdata->plaintext.len);
12309
12310         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12311                         tdata);
12312
12313         if (retval < 0)
12314                 return retval;
12315
12316         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12317
12318         ut_params->op->sym->m_src = ut_params->ibuf;
12319
12320         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12321                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12322                         ut_params->op);
12323         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12324                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12325                                 ut_params->op, 0, 1, 0, 0);
12326         else
12327                 TEST_ASSERT_NOT_NULL(
12328                         process_crypto_request(ts_params->valid_devs[0],
12329                         ut_params->op), "failed to process sym crypto op");
12330
12331         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12332                         "crypto op processing failed");
12333
12334         if (ut_params->op->sym->m_dst) {
12335                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12336                                 uint8_t *, plaintext_pad_len);
12337         } else {
12338                 auth_tag = plaintext + plaintext_pad_len;
12339         }
12340
12341         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12342
12343         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12344                         auth_tag,
12345                         tdata->gmac_tag.data,
12346                         tdata->gmac_tag.len,
12347                         "GMAC Generated auth tag not as expected");
12348
12349         return 0;
12350 }
12351
12352 static int
12353 test_AES_GMAC_authentication_test_case_1(void)
12354 {
12355         return test_AES_GMAC_authentication(&gmac_test_case_1);
12356 }
12357
12358 static int
12359 test_AES_GMAC_authentication_test_case_2(void)
12360 {
12361         return test_AES_GMAC_authentication(&gmac_test_case_2);
12362 }
12363
12364 static int
12365 test_AES_GMAC_authentication_test_case_3(void)
12366 {
12367         return test_AES_GMAC_authentication(&gmac_test_case_3);
12368 }
12369
12370 static int
12371 test_AES_GMAC_authentication_test_case_4(void)
12372 {
12373         return test_AES_GMAC_authentication(&gmac_test_case_4);
12374 }
12375
12376 static int
12377 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12378 {
12379         struct crypto_testsuite_params *ts_params = &testsuite_params;
12380         struct crypto_unittest_params *ut_params = &unittest_params;
12381         int retval;
12382         uint32_t plaintext_pad_len;
12383         uint8_t *plaintext;
12384         struct rte_cryptodev_info dev_info;
12385
12386         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12387         uint64_t feat_flags = dev_info.feature_flags;
12388
12389         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12390                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12391                 printf("Device doesn't support RAW data-path APIs.\n");
12392                 return TEST_SKIPPED;
12393         }
12394
12395         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12396                               "No GMAC length in the source data");
12397
12398         /* Verify the capabilities */
12399         struct rte_cryptodev_sym_capability_idx cap_idx;
12400         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12401         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12402         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12403                         &cap_idx) == NULL)
12404                 return TEST_SKIPPED;
12405
12406         retval = create_gmac_session(ts_params->valid_devs[0],
12407                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12408
12409         if (retval == -ENOTSUP)
12410                 return TEST_SKIPPED;
12411         if (retval < 0)
12412                 return retval;
12413
12414         if (tdata->plaintext.len > MBUF_SIZE)
12415                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12416         else
12417                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12418         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12419                         "Failed to allocate input buffer in mempool");
12420
12421         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12422                         rte_pktmbuf_tailroom(ut_params->ibuf));
12423
12424         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12425
12426         /*
12427          * Runtime generate the large plain text instead of use hard code
12428          * plain text vector. It is done to avoid create huge source file
12429          * with the test vector.
12430          */
12431         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12432                 generate_gmac_large_plaintext(tdata->plaintext.data);
12433
12434         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12435                                 plaintext_pad_len);
12436         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12437
12438         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12439         debug_hexdump(stdout, "plaintext:", plaintext,
12440                         tdata->plaintext.len);
12441
12442         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12443                         tdata);
12444
12445         if (retval < 0)
12446                 return retval;
12447
12448         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12449
12450         ut_params->op->sym->m_src = ut_params->ibuf;
12451
12452         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12453                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12454                         ut_params->op);
12455         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12456                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12457                                 ut_params->op, 0, 1, 0, 0);
12458         else
12459                 TEST_ASSERT_NOT_NULL(
12460                         process_crypto_request(ts_params->valid_devs[0],
12461                         ut_params->op), "failed to process sym crypto op");
12462
12463         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12464                         "crypto op processing failed");
12465
12466         return 0;
12467
12468 }
12469
12470 static int
12471 test_AES_GMAC_authentication_verify_test_case_1(void)
12472 {
12473         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12474 }
12475
12476 static int
12477 test_AES_GMAC_authentication_verify_test_case_2(void)
12478 {
12479         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12480 }
12481
12482 static int
12483 test_AES_GMAC_authentication_verify_test_case_3(void)
12484 {
12485         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12486 }
12487
12488 static int
12489 test_AES_GMAC_authentication_verify_test_case_4(void)
12490 {
12491         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12492 }
12493
12494 static int
12495 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12496                                 uint32_t fragsz)
12497 {
12498         struct crypto_testsuite_params *ts_params = &testsuite_params;
12499         struct crypto_unittest_params *ut_params = &unittest_params;
12500         struct rte_cryptodev_info dev_info;
12501         uint64_t feature_flags;
12502         unsigned int trn_data = 0;
12503         void *digest_mem = NULL;
12504         uint32_t segs = 1;
12505         unsigned int to_trn = 0;
12506         struct rte_mbuf *buf = NULL;
12507         uint8_t *auth_tag, *plaintext;
12508         int retval;
12509
12510         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12511                               "No GMAC length in the source data");
12512
12513         /* Verify the capabilities */
12514         struct rte_cryptodev_sym_capability_idx cap_idx;
12515         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12516         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12517         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12518                         &cap_idx) == NULL)
12519                 return TEST_SKIPPED;
12520
12521         /* Check for any input SGL support */
12522         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12523         feature_flags = dev_info.feature_flags;
12524
12525         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12526                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12527                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12528                 return TEST_SKIPPED;
12529
12530         if (fragsz > tdata->plaintext.len)
12531                 fragsz = tdata->plaintext.len;
12532
12533         uint16_t plaintext_len = fragsz;
12534
12535         retval = create_gmac_session(ts_params->valid_devs[0],
12536                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12537
12538         if (retval == -ENOTSUP)
12539                 return TEST_SKIPPED;
12540         if (retval < 0)
12541                 return retval;
12542
12543         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12544         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12545                         "Failed to allocate input buffer in mempool");
12546
12547         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12548                         rte_pktmbuf_tailroom(ut_params->ibuf));
12549
12550         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12551                                 plaintext_len);
12552         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12553
12554         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12555
12556         trn_data += plaintext_len;
12557
12558         buf = ut_params->ibuf;
12559
12560         /*
12561          * Loop until no more fragments
12562          */
12563
12564         while (trn_data < tdata->plaintext.len) {
12565                 ++segs;
12566                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12567                                 (tdata->plaintext.len - trn_data) : fragsz;
12568
12569                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12570                 buf = buf->next;
12571
12572                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12573                                 rte_pktmbuf_tailroom(buf));
12574
12575                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12576                                 to_trn);
12577
12578                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12579                                 to_trn);
12580                 trn_data += to_trn;
12581                 if (trn_data  == tdata->plaintext.len)
12582                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12583                                         tdata->gmac_tag.len);
12584         }
12585         ut_params->ibuf->nb_segs = segs;
12586
12587         /*
12588          * Place digest at the end of the last buffer
12589          */
12590         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12591
12592         if (!digest_mem) {
12593                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12594                                 + tdata->gmac_tag.len);
12595                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12596                                 tdata->plaintext.len);
12597         }
12598
12599         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12600                         tdata, digest_mem, digest_phys);
12601
12602         if (retval < 0)
12603                 return retval;
12604
12605         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12606
12607         ut_params->op->sym->m_src = ut_params->ibuf;
12608
12609         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12610                 return TEST_SKIPPED;
12611
12612         TEST_ASSERT_NOT_NULL(
12613                 process_crypto_request(ts_params->valid_devs[0],
12614                 ut_params->op), "failed to process sym crypto op");
12615
12616         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12617                         "crypto op processing failed");
12618
12619         auth_tag = digest_mem;
12620         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12621         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12622                         auth_tag,
12623                         tdata->gmac_tag.data,
12624                         tdata->gmac_tag.len,
12625                         "GMAC Generated auth tag not as expected");
12626
12627         return 0;
12628 }
12629
12630 /* Segment size not multiple of block size (16B) */
12631 static int
12632 test_AES_GMAC_authentication_SGL_40B(void)
12633 {
12634         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12635 }
12636
12637 static int
12638 test_AES_GMAC_authentication_SGL_80B(void)
12639 {
12640         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12641 }
12642
12643 static int
12644 test_AES_GMAC_authentication_SGL_2048B(void)
12645 {
12646         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12647 }
12648
12649 /* Segment size not multiple of block size (16B) */
12650 static int
12651 test_AES_GMAC_authentication_SGL_2047B(void)
12652 {
12653         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12654 }
12655
12656 struct test_crypto_vector {
12657         enum rte_crypto_cipher_algorithm crypto_algo;
12658         unsigned int cipher_offset;
12659         unsigned int cipher_len;
12660
12661         struct {
12662                 uint8_t data[64];
12663                 unsigned int len;
12664         } cipher_key;
12665
12666         struct {
12667                 uint8_t data[64];
12668                 unsigned int len;
12669         } iv;
12670
12671         struct {
12672                 const uint8_t *data;
12673                 unsigned int len;
12674         } plaintext;
12675
12676         struct {
12677                 const uint8_t *data;
12678                 unsigned int len;
12679         } ciphertext;
12680
12681         enum rte_crypto_auth_algorithm auth_algo;
12682         unsigned int auth_offset;
12683
12684         struct {
12685                 uint8_t data[128];
12686                 unsigned int len;
12687         } auth_key;
12688
12689         struct {
12690                 const uint8_t *data;
12691                 unsigned int len;
12692         } aad;
12693
12694         struct {
12695                 uint8_t data[128];
12696                 unsigned int len;
12697         } digest;
12698 };
12699
12700 static const struct test_crypto_vector
12701 hmac_sha1_test_crypto_vector = {
12702         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12703         .plaintext = {
12704                 .data = plaintext_hash,
12705                 .len = 512
12706         },
12707         .auth_key = {
12708                 .data = {
12709                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12710                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12711                         0xDE, 0xF4, 0xDE, 0xAD
12712                 },
12713                 .len = 20
12714         },
12715         .digest = {
12716                 .data = {
12717                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12718                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12719                         0x3F, 0x91, 0x64, 0x59
12720                 },
12721                 .len = 20
12722         }
12723 };
12724
12725 static const struct test_crypto_vector
12726 aes128_gmac_test_vector = {
12727         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12728         .plaintext = {
12729                 .data = plaintext_hash,
12730                 .len = 512
12731         },
12732         .iv = {
12733                 .data = {
12734                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12735                         0x08, 0x09, 0x0A, 0x0B
12736                 },
12737                 .len = 12
12738         },
12739         .auth_key = {
12740                 .data = {
12741                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12742                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12743                 },
12744                 .len = 16
12745         },
12746         .digest = {
12747                 .data = {
12748                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
12749                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
12750                 },
12751                 .len = 16
12752         }
12753 };
12754
12755 static const struct test_crypto_vector
12756 aes128cbc_hmac_sha1_test_vector = {
12757         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12758         .cipher_offset = 0,
12759         .cipher_len = 512,
12760         .cipher_key = {
12761                 .data = {
12762                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12763                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12764                 },
12765                 .len = 16
12766         },
12767         .iv = {
12768                 .data = {
12769                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12770                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12771                 },
12772                 .len = 16
12773         },
12774         .plaintext = {
12775                 .data = plaintext_hash,
12776                 .len = 512
12777         },
12778         .ciphertext = {
12779                 .data = ciphertext512_aes128cbc,
12780                 .len = 512
12781         },
12782         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12783         .auth_offset = 0,
12784         .auth_key = {
12785                 .data = {
12786                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12787                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12788                         0xDE, 0xF4, 0xDE, 0xAD
12789                 },
12790                 .len = 20
12791         },
12792         .digest = {
12793                 .data = {
12794                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
12795                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12796                         0x18, 0x8C, 0x1D, 0x32
12797                 },
12798                 .len = 20
12799         }
12800 };
12801
12802 static const struct test_crypto_vector
12803 aes128cbc_hmac_sha1_aad_test_vector = {
12804         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
12805         .cipher_offset = 8,
12806         .cipher_len = 496,
12807         .cipher_key = {
12808                 .data = {
12809                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
12810                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
12811                 },
12812                 .len = 16
12813         },
12814         .iv = {
12815                 .data = {
12816                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12817                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
12818                 },
12819                 .len = 16
12820         },
12821         .plaintext = {
12822                 .data = plaintext_hash,
12823                 .len = 512
12824         },
12825         .ciphertext = {
12826                 .data = ciphertext512_aes128cbc_aad,
12827                 .len = 512
12828         },
12829         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12830         .auth_offset = 0,
12831         .auth_key = {
12832                 .data = {
12833                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12834                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12835                         0xDE, 0xF4, 0xDE, 0xAD
12836                 },
12837                 .len = 20
12838         },
12839         .digest = {
12840                 .data = {
12841                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
12842                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
12843                         0x62, 0x0F, 0xFB, 0x10
12844                 },
12845                 .len = 20
12846         }
12847 };
12848
12849 static void
12850 data_corruption(uint8_t *data)
12851 {
12852         data[0] += 1;
12853 }
12854
12855 static void
12856 tag_corruption(uint8_t *data, unsigned int tag_offset)
12857 {
12858         data[tag_offset] += 1;
12859 }
12860
12861 static int
12862 create_auth_session(struct crypto_unittest_params *ut_params,
12863                 uint8_t dev_id,
12864                 const struct test_crypto_vector *reference,
12865                 enum rte_crypto_auth_operation auth_op)
12866 {
12867         struct crypto_testsuite_params *ts_params = &testsuite_params;
12868         uint8_t auth_key[reference->auth_key.len + 1];
12869         int status;
12870
12871         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12872
12873         /* Setup Authentication Parameters */
12874         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12875         ut_params->auth_xform.auth.op = auth_op;
12876         ut_params->auth_xform.next = NULL;
12877         ut_params->auth_xform.auth.algo = reference->auth_algo;
12878         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12879         ut_params->auth_xform.auth.key.data = auth_key;
12880         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12881
12882         /* Create Crypto session*/
12883         ut_params->sess = rte_cryptodev_sym_session_create(
12884                         ts_params->session_mpool);
12885         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12886
12887         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12888                                 &ut_params->auth_xform,
12889                                 ts_params->session_priv_mpool);
12890
12891         return status;
12892 }
12893
12894 static int
12895 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
12896                 uint8_t dev_id,
12897                 const struct test_crypto_vector *reference,
12898                 enum rte_crypto_auth_operation auth_op,
12899                 enum rte_crypto_cipher_operation cipher_op)
12900 {
12901         struct crypto_testsuite_params *ts_params = &testsuite_params;
12902         uint8_t cipher_key[reference->cipher_key.len + 1];
12903         uint8_t auth_key[reference->auth_key.len + 1];
12904         int status;
12905
12906         memcpy(cipher_key, reference->cipher_key.data,
12907                         reference->cipher_key.len);
12908         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
12909
12910         /* Setup Authentication Parameters */
12911         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12912         ut_params->auth_xform.auth.op = auth_op;
12913         ut_params->auth_xform.auth.algo = reference->auth_algo;
12914         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
12915         ut_params->auth_xform.auth.key.data = auth_key;
12916         ut_params->auth_xform.auth.digest_length = reference->digest.len;
12917
12918         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
12919                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12920                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
12921         } else {
12922                 ut_params->auth_xform.next = &ut_params->cipher_xform;
12923
12924                 /* Setup Cipher Parameters */
12925                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12926                 ut_params->cipher_xform.next = NULL;
12927                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
12928                 ut_params->cipher_xform.cipher.op = cipher_op;
12929                 ut_params->cipher_xform.cipher.key.data = cipher_key;
12930                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
12931                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
12932                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
12933         }
12934
12935         /* Create Crypto session*/
12936         ut_params->sess = rte_cryptodev_sym_session_create(
12937                         ts_params->session_mpool);
12938         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12939
12940         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12941                                 &ut_params->auth_xform,
12942                                 ts_params->session_priv_mpool);
12943
12944         return status;
12945 }
12946
12947 static int
12948 create_auth_operation(struct crypto_testsuite_params *ts_params,
12949                 struct crypto_unittest_params *ut_params,
12950                 const struct test_crypto_vector *reference,
12951                 unsigned int auth_generate)
12952 {
12953         /* Generate Crypto op data structure */
12954         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12955                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12956         TEST_ASSERT_NOT_NULL(ut_params->op,
12957                         "Failed to allocate pktmbuf offload");
12958
12959         /* Set crypto operation data parameters */
12960         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12961
12962         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
12963
12964         /* set crypto operation source mbuf */
12965         sym_op->m_src = ut_params->ibuf;
12966
12967         /* digest */
12968         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12969                         ut_params->ibuf, reference->digest.len);
12970
12971         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12972                         "no room to append auth tag");
12973
12974         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12975                         ut_params->ibuf, reference->plaintext.len);
12976
12977         if (auth_generate)
12978                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
12979         else
12980                 memcpy(sym_op->auth.digest.data,
12981                                 reference->digest.data,
12982                                 reference->digest.len);
12983
12984         debug_hexdump(stdout, "digest:",
12985                         sym_op->auth.digest.data,
12986                         reference->digest.len);
12987
12988         sym_op->auth.data.length = reference->plaintext.len;
12989         sym_op->auth.data.offset = 0;
12990
12991         return 0;
12992 }
12993
12994 static int
12995 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
12996                 struct crypto_unittest_params *ut_params,
12997                 const struct test_crypto_vector *reference,
12998                 unsigned int auth_generate)
12999 {
13000         /* Generate Crypto op data structure */
13001         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13002                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13003         TEST_ASSERT_NOT_NULL(ut_params->op,
13004                         "Failed to allocate pktmbuf offload");
13005
13006         /* Set crypto operation data parameters */
13007         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13008
13009         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13010
13011         /* set crypto operation source mbuf */
13012         sym_op->m_src = ut_params->ibuf;
13013
13014         /* digest */
13015         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13016                         ut_params->ibuf, reference->digest.len);
13017
13018         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13019                         "no room to append auth tag");
13020
13021         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13022                         ut_params->ibuf, reference->ciphertext.len);
13023
13024         if (auth_generate)
13025                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13026         else
13027                 memcpy(sym_op->auth.digest.data,
13028                                 reference->digest.data,
13029                                 reference->digest.len);
13030
13031         debug_hexdump(stdout, "digest:",
13032                         sym_op->auth.digest.data,
13033                         reference->digest.len);
13034
13035         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13036                         reference->iv.data, reference->iv.len);
13037
13038         sym_op->cipher.data.length = 0;
13039         sym_op->cipher.data.offset = 0;
13040
13041         sym_op->auth.data.length = reference->plaintext.len;
13042         sym_op->auth.data.offset = 0;
13043
13044         return 0;
13045 }
13046
13047 static int
13048 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13049                 struct crypto_unittest_params *ut_params,
13050                 const struct test_crypto_vector *reference,
13051                 unsigned int auth_generate)
13052 {
13053         /* Generate Crypto op data structure */
13054         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13055                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13056         TEST_ASSERT_NOT_NULL(ut_params->op,
13057                         "Failed to allocate pktmbuf offload");
13058
13059         /* Set crypto operation data parameters */
13060         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13061
13062         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13063
13064         /* set crypto operation source mbuf */
13065         sym_op->m_src = ut_params->ibuf;
13066
13067         /* digest */
13068         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13069                         ut_params->ibuf, reference->digest.len);
13070
13071         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13072                         "no room to append auth tag");
13073
13074         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13075                         ut_params->ibuf, reference->ciphertext.len);
13076
13077         if (auth_generate)
13078                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13079         else
13080                 memcpy(sym_op->auth.digest.data,
13081                                 reference->digest.data,
13082                                 reference->digest.len);
13083
13084         debug_hexdump(stdout, "digest:",
13085                         sym_op->auth.digest.data,
13086                         reference->digest.len);
13087
13088         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13089                         reference->iv.data, reference->iv.len);
13090
13091         sym_op->cipher.data.length = reference->cipher_len;
13092         sym_op->cipher.data.offset = reference->cipher_offset;
13093
13094         sym_op->auth.data.length = reference->plaintext.len;
13095         sym_op->auth.data.offset = reference->auth_offset;
13096
13097         return 0;
13098 }
13099
13100 static int
13101 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13102                 struct crypto_unittest_params *ut_params,
13103                 const struct test_crypto_vector *reference)
13104 {
13105         return create_auth_operation(ts_params, ut_params, reference, 0);
13106 }
13107
13108 static int
13109 create_auth_verify_GMAC_operation(
13110                 struct crypto_testsuite_params *ts_params,
13111                 struct crypto_unittest_params *ut_params,
13112                 const struct test_crypto_vector *reference)
13113 {
13114         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13115 }
13116
13117 static int
13118 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13119                 struct crypto_unittest_params *ut_params,
13120                 const struct test_crypto_vector *reference)
13121 {
13122         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13123 }
13124
13125 static int
13126 test_authentication_verify_fail_when_data_corruption(
13127                 struct crypto_testsuite_params *ts_params,
13128                 struct crypto_unittest_params *ut_params,
13129                 const struct test_crypto_vector *reference,
13130                 unsigned int data_corrupted)
13131 {
13132         int retval;
13133
13134         uint8_t *plaintext;
13135         struct rte_cryptodev_info dev_info;
13136
13137         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13138         uint64_t feat_flags = dev_info.feature_flags;
13139
13140         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13141                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13142                 printf("Device doesn't support RAW data-path APIs.\n");
13143                 return TEST_SKIPPED;
13144         }
13145
13146         /* Verify the capabilities */
13147         struct rte_cryptodev_sym_capability_idx cap_idx;
13148         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13149         cap_idx.algo.auth = reference->auth_algo;
13150         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13151                         &cap_idx) == NULL)
13152                 return TEST_SKIPPED;
13153
13154
13155         /* Create session */
13156         retval = create_auth_session(ut_params,
13157                         ts_params->valid_devs[0],
13158                         reference,
13159                         RTE_CRYPTO_AUTH_OP_VERIFY);
13160
13161         if (retval == -ENOTSUP)
13162                 return TEST_SKIPPED;
13163         if (retval < 0)
13164                 return retval;
13165
13166         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13167         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13168                         "Failed to allocate input buffer in mempool");
13169
13170         /* clear mbuf payload */
13171         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13172                         rte_pktmbuf_tailroom(ut_params->ibuf));
13173
13174         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13175                         reference->plaintext.len);
13176         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13177         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13178
13179         debug_hexdump(stdout, "plaintext:", plaintext,
13180                 reference->plaintext.len);
13181
13182         /* Create operation */
13183         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13184
13185         if (retval < 0)
13186                 return retval;
13187
13188         if (data_corrupted)
13189                 data_corruption(plaintext);
13190         else
13191                 tag_corruption(plaintext, reference->plaintext.len);
13192
13193         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13194                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13195                         ut_params->op);
13196                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13197                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13198                         "authentication not failed");
13199         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13200                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13201                                 ut_params->op, 0, 1, 0, 0);
13202         else {
13203                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13204                         ut_params->op);
13205         }
13206         if (ut_params->op == NULL)
13207                 return 0;
13208         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13209                 return 0;
13210
13211         return -1;
13212 }
13213
13214 static int
13215 test_authentication_verify_GMAC_fail_when_corruption(
13216                 struct crypto_testsuite_params *ts_params,
13217                 struct crypto_unittest_params *ut_params,
13218                 const struct test_crypto_vector *reference,
13219                 unsigned int data_corrupted)
13220 {
13221         int retval;
13222         uint8_t *plaintext;
13223         struct rte_cryptodev_info dev_info;
13224
13225         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13226         uint64_t feat_flags = dev_info.feature_flags;
13227
13228         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13229                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13230                 printf("Device doesn't support RAW data-path APIs.\n");
13231                 return TEST_SKIPPED;
13232         }
13233
13234         /* Verify the capabilities */
13235         struct rte_cryptodev_sym_capability_idx cap_idx;
13236         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13237         cap_idx.algo.auth = reference->auth_algo;
13238         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13239                         &cap_idx) == NULL)
13240                 return TEST_SKIPPED;
13241
13242         /* Create session */
13243         retval = create_auth_cipher_session(ut_params,
13244                         ts_params->valid_devs[0],
13245                         reference,
13246                         RTE_CRYPTO_AUTH_OP_VERIFY,
13247                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13248         if (retval < 0)
13249                 return retval;
13250
13251         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13252         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13253                         "Failed to allocate input buffer in mempool");
13254
13255         /* clear mbuf payload */
13256         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13257                         rte_pktmbuf_tailroom(ut_params->ibuf));
13258
13259         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13260                         reference->plaintext.len);
13261         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13262         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13263
13264         debug_hexdump(stdout, "plaintext:", plaintext,
13265                 reference->plaintext.len);
13266
13267         /* Create operation */
13268         retval = create_auth_verify_GMAC_operation(ts_params,
13269                         ut_params,
13270                         reference);
13271
13272         if (retval < 0)
13273                 return retval;
13274
13275         if (data_corrupted)
13276                 data_corruption(plaintext);
13277         else
13278                 tag_corruption(plaintext, reference->aad.len);
13279
13280         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13281                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13282                         ut_params->op);
13283                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13284                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13285                         "authentication not failed");
13286         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13287                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13288                                 ut_params->op, 0, 1, 0, 0);
13289         else {
13290                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13291                         ut_params->op);
13292                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13293         }
13294
13295         return 0;
13296 }
13297
13298 static int
13299 test_authenticated_decryption_fail_when_corruption(
13300                 struct crypto_testsuite_params *ts_params,
13301                 struct crypto_unittest_params *ut_params,
13302                 const struct test_crypto_vector *reference,
13303                 unsigned int data_corrupted)
13304 {
13305         int retval;
13306
13307         uint8_t *ciphertext;
13308         struct rte_cryptodev_info dev_info;
13309
13310         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13311         uint64_t feat_flags = dev_info.feature_flags;
13312
13313         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13314                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13315                 printf("Device doesn't support RAW data-path APIs.\n");
13316                 return TEST_SKIPPED;
13317         }
13318
13319         /* Verify the capabilities */
13320         struct rte_cryptodev_sym_capability_idx cap_idx;
13321         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13322         cap_idx.algo.auth = reference->auth_algo;
13323         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13324                         &cap_idx) == NULL)
13325                 return TEST_SKIPPED;
13326         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13327         cap_idx.algo.cipher = reference->crypto_algo;
13328         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13329                         &cap_idx) == NULL)
13330                 return TEST_SKIPPED;
13331
13332         /* Create session */
13333         retval = create_auth_cipher_session(ut_params,
13334                         ts_params->valid_devs[0],
13335                         reference,
13336                         RTE_CRYPTO_AUTH_OP_VERIFY,
13337                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13338
13339         if (retval == -ENOTSUP)
13340                 return TEST_SKIPPED;
13341         if (retval < 0)
13342                 return retval;
13343
13344         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13345         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13346                         "Failed to allocate input buffer in mempool");
13347
13348         /* clear mbuf payload */
13349         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13350                         rte_pktmbuf_tailroom(ut_params->ibuf));
13351
13352         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13353                         reference->ciphertext.len);
13354         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13355         memcpy(ciphertext, reference->ciphertext.data,
13356                         reference->ciphertext.len);
13357
13358         /* Create operation */
13359         retval = create_cipher_auth_verify_operation(ts_params,
13360                         ut_params,
13361                         reference);
13362
13363         if (retval < 0)
13364                 return retval;
13365
13366         if (data_corrupted)
13367                 data_corruption(ciphertext);
13368         else
13369                 tag_corruption(ciphertext, reference->ciphertext.len);
13370
13371         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13372                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13373                         ut_params->op);
13374                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13375                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13376                         "authentication not failed");
13377         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13378                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13379                                 ut_params->op, 1, 1, 0, 0);
13380         else {
13381                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13382                         ut_params->op);
13383                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13384         }
13385
13386         return 0;
13387 }
13388
13389 static int
13390 test_authenticated_encrypt_with_esn(
13391                 struct crypto_testsuite_params *ts_params,
13392                 struct crypto_unittest_params *ut_params,
13393                 const struct test_crypto_vector *reference)
13394 {
13395         int retval;
13396
13397         uint8_t *authciphertext, *plaintext, *auth_tag;
13398         uint16_t plaintext_pad_len;
13399         uint8_t cipher_key[reference->cipher_key.len + 1];
13400         uint8_t auth_key[reference->auth_key.len + 1];
13401         struct rte_cryptodev_info dev_info;
13402         int status;
13403
13404         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13405         uint64_t feat_flags = dev_info.feature_flags;
13406
13407         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13408                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13409                 printf("Device doesn't support RAW data-path APIs.\n");
13410                 return TEST_SKIPPED;
13411         }
13412
13413         /* Verify the capabilities */
13414         struct rte_cryptodev_sym_capability_idx cap_idx;
13415         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13416         cap_idx.algo.auth = reference->auth_algo;
13417         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13418                         &cap_idx) == NULL)
13419                 return TEST_SKIPPED;
13420         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13421         cap_idx.algo.cipher = reference->crypto_algo;
13422         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13423                         &cap_idx) == NULL)
13424                 return TEST_SKIPPED;
13425
13426         /* Create session */
13427         memcpy(cipher_key, reference->cipher_key.data,
13428                         reference->cipher_key.len);
13429         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13430
13431         /* Setup Cipher Parameters */
13432         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13433         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13434         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13435         ut_params->cipher_xform.cipher.key.data = cipher_key;
13436         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13437         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13438         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13439
13440         ut_params->cipher_xform.next = &ut_params->auth_xform;
13441
13442         /* Setup Authentication Parameters */
13443         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13444         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13445         ut_params->auth_xform.auth.algo = reference->auth_algo;
13446         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13447         ut_params->auth_xform.auth.key.data = auth_key;
13448         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13449         ut_params->auth_xform.next = NULL;
13450
13451         /* Create Crypto session*/
13452         ut_params->sess = rte_cryptodev_sym_session_create(
13453                         ts_params->session_mpool);
13454         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13455
13456         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13457                                 ut_params->sess,
13458                                 &ut_params->cipher_xform,
13459                                 ts_params->session_priv_mpool);
13460
13461         if (status == -ENOTSUP)
13462                 return TEST_SKIPPED;
13463
13464         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13465
13466         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13467         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13468                         "Failed to allocate input buffer in mempool");
13469
13470         /* clear mbuf payload */
13471         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13472                         rte_pktmbuf_tailroom(ut_params->ibuf));
13473
13474         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13475                         reference->plaintext.len);
13476         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13477         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13478
13479         /* Create operation */
13480         retval = create_cipher_auth_operation(ts_params,
13481                         ut_params,
13482                         reference, 0);
13483
13484         if (retval < 0)
13485                 return retval;
13486
13487         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13488                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13489                         ut_params->op);
13490         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13491                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13492                                 ut_params->op, 1, 1, 0, 0);
13493         else
13494                 ut_params->op = process_crypto_request(
13495                         ts_params->valid_devs[0], ut_params->op);
13496
13497         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13498
13499         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13500                         "crypto op processing failed");
13501
13502         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13503
13504         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13505                         ut_params->op->sym->auth.data.offset);
13506         auth_tag = authciphertext + plaintext_pad_len;
13507         debug_hexdump(stdout, "ciphertext:", authciphertext,
13508                         reference->ciphertext.len);
13509         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13510
13511         /* Validate obuf */
13512         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13513                         authciphertext,
13514                         reference->ciphertext.data,
13515                         reference->ciphertext.len,
13516                         "Ciphertext data not as expected");
13517
13518         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13519                         auth_tag,
13520                         reference->digest.data,
13521                         reference->digest.len,
13522                         "Generated digest not as expected");
13523
13524         return TEST_SUCCESS;
13525
13526 }
13527
13528 static int
13529 test_authenticated_decrypt_with_esn(
13530                 struct crypto_testsuite_params *ts_params,
13531                 struct crypto_unittest_params *ut_params,
13532                 const struct test_crypto_vector *reference)
13533 {
13534         int retval;
13535
13536         uint8_t *ciphertext;
13537         uint8_t cipher_key[reference->cipher_key.len + 1];
13538         uint8_t auth_key[reference->auth_key.len + 1];
13539         struct rte_cryptodev_info dev_info;
13540
13541         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13542         uint64_t feat_flags = dev_info.feature_flags;
13543
13544         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13545                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13546                 printf("Device doesn't support RAW data-path APIs.\n");
13547                 return TEST_SKIPPED;
13548         }
13549
13550         /* Verify the capabilities */
13551         struct rte_cryptodev_sym_capability_idx cap_idx;
13552         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13553         cap_idx.algo.auth = reference->auth_algo;
13554         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13555                         &cap_idx) == NULL)
13556                 return TEST_SKIPPED;
13557         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13558         cap_idx.algo.cipher = reference->crypto_algo;
13559         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13560                         &cap_idx) == NULL)
13561                 return TEST_SKIPPED;
13562
13563         /* Create session */
13564         memcpy(cipher_key, reference->cipher_key.data,
13565                         reference->cipher_key.len);
13566         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13567
13568         /* Setup Authentication Parameters */
13569         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13570         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13571         ut_params->auth_xform.auth.algo = reference->auth_algo;
13572         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13573         ut_params->auth_xform.auth.key.data = auth_key;
13574         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13575         ut_params->auth_xform.next = &ut_params->cipher_xform;
13576
13577         /* Setup Cipher Parameters */
13578         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13579         ut_params->cipher_xform.next = NULL;
13580         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13581         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13582         ut_params->cipher_xform.cipher.key.data = cipher_key;
13583         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13584         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13585         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13586
13587         /* Create Crypto session*/
13588         ut_params->sess = rte_cryptodev_sym_session_create(
13589                         ts_params->session_mpool);
13590         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13591
13592         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13593                                 ut_params->sess,
13594                                 &ut_params->auth_xform,
13595                                 ts_params->session_priv_mpool);
13596
13597         if (retval == -ENOTSUP)
13598                 return TEST_SKIPPED;
13599
13600         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
13601
13602         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13603         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13604                         "Failed to allocate input buffer in mempool");
13605
13606         /* clear mbuf payload */
13607         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13608                         rte_pktmbuf_tailroom(ut_params->ibuf));
13609
13610         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13611                         reference->ciphertext.len);
13612         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13613         memcpy(ciphertext, reference->ciphertext.data,
13614                         reference->ciphertext.len);
13615
13616         /* Create operation */
13617         retval = create_cipher_auth_verify_operation(ts_params,
13618                         ut_params,
13619                         reference);
13620
13621         if (retval < 0)
13622                 return retval;
13623
13624         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13625                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13626                         ut_params->op);
13627         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13628                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13629                                 ut_params->op, 1, 1, 0, 0);
13630         else
13631                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13632                         ut_params->op);
13633
13634         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13635         TEST_ASSERT_EQUAL(ut_params->op->status,
13636                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13637                         "crypto op processing passed");
13638
13639         ut_params->obuf = ut_params->op->sym->m_src;
13640         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13641
13642         return 0;
13643 }
13644
13645 static int
13646 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13647                 const struct aead_test_data *tdata,
13648                 void *digest_mem, uint64_t digest_phys)
13649 {
13650         struct crypto_testsuite_params *ts_params = &testsuite_params;
13651         struct crypto_unittest_params *ut_params = &unittest_params;
13652
13653         const unsigned int auth_tag_len = tdata->auth_tag.len;
13654         const unsigned int iv_len = tdata->iv.len;
13655         unsigned int aad_len = tdata->aad.len;
13656         unsigned int aad_len_pad = 0;
13657
13658         /* Generate Crypto op data structure */
13659         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13660                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13661         TEST_ASSERT_NOT_NULL(ut_params->op,
13662                 "Failed to allocate symmetric crypto operation struct");
13663
13664         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13665
13666         sym_op->aead.digest.data = digest_mem;
13667
13668         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13669                         "no room to append digest");
13670
13671         sym_op->aead.digest.phys_addr = digest_phys;
13672
13673         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13674                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13675                                 auth_tag_len);
13676                 debug_hexdump(stdout, "digest:",
13677                                 sym_op->aead.digest.data,
13678                                 auth_tag_len);
13679         }
13680
13681         /* Append aad data */
13682         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13683                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13684                                 uint8_t *, IV_OFFSET);
13685
13686                 /* Copy IV 1 byte after the IV pointer, according to the API */
13687                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13688
13689                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13690
13691                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13692                                 ut_params->ibuf, aad_len);
13693                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13694                                 "no room to prepend aad");
13695                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13696                                 ut_params->ibuf);
13697
13698                 memset(sym_op->aead.aad.data, 0, aad_len);
13699                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13700                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13701
13702                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13703                 debug_hexdump(stdout, "aad:",
13704                                 sym_op->aead.aad.data, aad_len);
13705         } else {
13706                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13707                                 uint8_t *, IV_OFFSET);
13708
13709                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13710
13711                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13712
13713                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13714                                 ut_params->ibuf, aad_len_pad);
13715                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13716                                 "no room to prepend aad");
13717                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13718                                 ut_params->ibuf);
13719
13720                 memset(sym_op->aead.aad.data, 0, aad_len);
13721                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13722
13723                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13724                 debug_hexdump(stdout, "aad:",
13725                                 sym_op->aead.aad.data, aad_len);
13726         }
13727
13728         sym_op->aead.data.length = tdata->plaintext.len;
13729         sym_op->aead.data.offset = aad_len_pad;
13730
13731         return 0;
13732 }
13733
13734 #define SGL_MAX_NO      16
13735
13736 static int
13737 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13738                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13739 {
13740         struct crypto_testsuite_params *ts_params = &testsuite_params;
13741         struct crypto_unittest_params *ut_params = &unittest_params;
13742         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13743         int retval;
13744         int to_trn = 0;
13745         int to_trn_tbl[SGL_MAX_NO];
13746         int segs = 1;
13747         unsigned int trn_data = 0;
13748         uint8_t *plaintext, *ciphertext, *auth_tag;
13749         struct rte_cryptodev_info dev_info;
13750
13751         /* Verify the capabilities */
13752         struct rte_cryptodev_sym_capability_idx cap_idx;
13753         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
13754         cap_idx.algo.aead = tdata->algo;
13755         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13756                         &cap_idx) == NULL)
13757                 return TEST_SKIPPED;
13758
13759         /* OOP not supported with CPU crypto */
13760         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13761                 return TEST_SKIPPED;
13762
13763         /* Detailed check for the particular SGL support flag */
13764         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13765         if (!oop) {
13766                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13767                 if (sgl_in && (!(dev_info.feature_flags &
13768                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
13769                         return TEST_SKIPPED;
13770
13771                 uint64_t feat_flags = dev_info.feature_flags;
13772
13773                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13774                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13775                         printf("Device doesn't support RAW data-path APIs.\n");
13776                         return TEST_SKIPPED;
13777                 }
13778         } else {
13779                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
13780                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
13781                                 tdata->plaintext.len;
13782                 /* Raw data path API does not support OOP */
13783                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13784                         return TEST_SKIPPED;
13785                 if (sgl_in && !sgl_out) {
13786                         if (!(dev_info.feature_flags &
13787                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
13788                                 return TEST_SKIPPED;
13789                 } else if (!sgl_in && sgl_out) {
13790                         if (!(dev_info.feature_flags &
13791                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
13792                                 return TEST_SKIPPED;
13793                 } else if (sgl_in && sgl_out) {
13794                         if (!(dev_info.feature_flags &
13795                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
13796                                 return TEST_SKIPPED;
13797                 }
13798         }
13799
13800         if (fragsz > tdata->plaintext.len)
13801                 fragsz = tdata->plaintext.len;
13802
13803         uint16_t plaintext_len = fragsz;
13804         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
13805
13806         if (fragsz_oop > tdata->plaintext.len)
13807                 frag_size_oop = tdata->plaintext.len;
13808
13809         int ecx = 0;
13810         void *digest_mem = NULL;
13811
13812         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
13813
13814         if (tdata->plaintext.len % fragsz != 0) {
13815                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
13816                         return 1;
13817         }       else {
13818                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
13819                         return 1;
13820         }
13821
13822         /*
13823          * For out-op-place we need to alloc another mbuf
13824          */
13825         if (oop) {
13826                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13827                 rte_pktmbuf_append(ut_params->obuf,
13828                                 frag_size_oop + prepend_len);
13829                 buf_oop = ut_params->obuf;
13830         }
13831
13832         /* Create AEAD session */
13833         retval = create_aead_session(ts_params->valid_devs[0],
13834                         tdata->algo,
13835                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
13836                         tdata->key.data, tdata->key.len,
13837                         tdata->aad.len, tdata->auth_tag.len,
13838                         tdata->iv.len);
13839         if (retval < 0)
13840                 return retval;
13841
13842         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13843
13844         /* clear mbuf payload */
13845         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13846                         rte_pktmbuf_tailroom(ut_params->ibuf));
13847
13848         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13849                         plaintext_len);
13850
13851         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13852
13853         trn_data += plaintext_len;
13854
13855         buf = ut_params->ibuf;
13856
13857         /*
13858          * Loop until no more fragments
13859          */
13860
13861         while (trn_data < tdata->plaintext.len) {
13862                 ++segs;
13863                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13864                                 (tdata->plaintext.len - trn_data) : fragsz;
13865
13866                 to_trn_tbl[ecx++] = to_trn;
13867
13868                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13869                 buf = buf->next;
13870
13871                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13872                                 rte_pktmbuf_tailroom(buf));
13873
13874                 /* OOP */
13875                 if (oop && !fragsz_oop) {
13876                         buf_last_oop = buf_oop->next =
13877                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13878                         buf_oop = buf_oop->next;
13879                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13880                                         0, rte_pktmbuf_tailroom(buf_oop));
13881                         rte_pktmbuf_append(buf_oop, to_trn);
13882                 }
13883
13884                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13885                                 to_trn);
13886
13887                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13888                                 to_trn);
13889                 trn_data += to_trn;
13890                 if (trn_data  == tdata->plaintext.len) {
13891                         if (oop) {
13892                                 if (!fragsz_oop)
13893                                         digest_mem = rte_pktmbuf_append(buf_oop,
13894                                                 tdata->auth_tag.len);
13895                         } else
13896                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13897                                         tdata->auth_tag.len);
13898                 }
13899         }
13900
13901         uint64_t digest_phys = 0;
13902
13903         ut_params->ibuf->nb_segs = segs;
13904
13905         segs = 1;
13906         if (fragsz_oop && oop) {
13907                 to_trn = 0;
13908                 ecx = 0;
13909
13910                 if (frag_size_oop == tdata->plaintext.len) {
13911                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
13912                                 tdata->auth_tag.len);
13913
13914                         digest_phys = rte_pktmbuf_iova_offset(
13915                                         ut_params->obuf,
13916                                         tdata->plaintext.len + prepend_len);
13917                 }
13918
13919                 trn_data = frag_size_oop;
13920                 while (trn_data < tdata->plaintext.len) {
13921                         ++segs;
13922                         to_trn =
13923                                 (tdata->plaintext.len - trn_data <
13924                                                 frag_size_oop) ?
13925                                 (tdata->plaintext.len - trn_data) :
13926                                                 frag_size_oop;
13927
13928                         to_trn_tbl[ecx++] = to_trn;
13929
13930                         buf_last_oop = buf_oop->next =
13931                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
13932                         buf_oop = buf_oop->next;
13933                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
13934                                         0, rte_pktmbuf_tailroom(buf_oop));
13935                         rte_pktmbuf_append(buf_oop, to_trn);
13936
13937                         trn_data += to_trn;
13938
13939                         if (trn_data  == tdata->plaintext.len) {
13940                                 digest_mem = rte_pktmbuf_append(buf_oop,
13941                                         tdata->auth_tag.len);
13942                         }
13943                 }
13944
13945                 ut_params->obuf->nb_segs = segs;
13946         }
13947
13948         /*
13949          * Place digest at the end of the last buffer
13950          */
13951         if (!digest_phys)
13952                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13953         if (oop && buf_last_oop)
13954                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
13955
13956         if (!digest_mem && !oop) {
13957                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13958                                 + tdata->auth_tag.len);
13959                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13960                                 tdata->plaintext.len);
13961         }
13962
13963         /* Create AEAD operation */
13964         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
13965                         tdata, digest_mem, digest_phys);
13966
13967         if (retval < 0)
13968                 return retval;
13969
13970         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13971
13972         ut_params->op->sym->m_src = ut_params->ibuf;
13973         if (oop)
13974                 ut_params->op->sym->m_dst = ut_params->obuf;
13975
13976         /* Process crypto operation */
13977         if (oop == IN_PLACE &&
13978                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13979                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
13980         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13981                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13982                                 ut_params->op, 0, 0, 0, 0);
13983         else
13984                 TEST_ASSERT_NOT_NULL(
13985                         process_crypto_request(ts_params->valid_devs[0],
13986                         ut_params->op), "failed to process sym crypto op");
13987
13988         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13989                         "crypto op processing failed");
13990
13991
13992         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
13993                         uint8_t *, prepend_len);
13994         if (oop) {
13995                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
13996                                 uint8_t *, prepend_len);
13997         }
13998
13999         if (fragsz_oop)
14000                 fragsz = fragsz_oop;
14001
14002         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14003                         ciphertext,
14004                         tdata->ciphertext.data,
14005                         fragsz,
14006                         "Ciphertext data not as expected");
14007
14008         buf = ut_params->op->sym->m_src->next;
14009         if (oop)
14010                 buf = ut_params->op->sym->m_dst->next;
14011
14012         unsigned int off = fragsz;
14013
14014         ecx = 0;
14015         while (buf) {
14016                 ciphertext = rte_pktmbuf_mtod(buf,
14017                                 uint8_t *);
14018
14019                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14020                                 ciphertext,
14021                                 tdata->ciphertext.data + off,
14022                                 to_trn_tbl[ecx],
14023                                 "Ciphertext data not as expected");
14024
14025                 off += to_trn_tbl[ecx++];
14026                 buf = buf->next;
14027         }
14028
14029         auth_tag = digest_mem;
14030         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14031                         auth_tag,
14032                         tdata->auth_tag.data,
14033                         tdata->auth_tag.len,
14034                         "Generated auth tag not as expected");
14035
14036         return 0;
14037 }
14038
14039 static int
14040 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14041 {
14042         return test_authenticated_encryption_SGL(
14043                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14044 }
14045
14046 static int
14047 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14048 {
14049         return test_authenticated_encryption_SGL(
14050                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14051 }
14052
14053 static int
14054 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14055 {
14056         return test_authenticated_encryption_SGL(
14057                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14058                         gcm_test_case_8.plaintext.len);
14059 }
14060
14061 static int
14062 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14063 {
14064         /* This test is not for OPENSSL PMD */
14065         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14066                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14067                 return TEST_SKIPPED;
14068
14069         return test_authenticated_encryption_SGL(
14070                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14071 }
14072
14073 static int
14074 test_authentication_verify_fail_when_data_corrupted(
14075                 struct crypto_testsuite_params *ts_params,
14076                 struct crypto_unittest_params *ut_params,
14077                 const struct test_crypto_vector *reference)
14078 {
14079         return test_authentication_verify_fail_when_data_corruption(
14080                         ts_params, ut_params, reference, 1);
14081 }
14082
14083 static int
14084 test_authentication_verify_fail_when_tag_corrupted(
14085                 struct crypto_testsuite_params *ts_params,
14086                 struct crypto_unittest_params *ut_params,
14087                 const struct test_crypto_vector *reference)
14088 {
14089         return test_authentication_verify_fail_when_data_corruption(
14090                         ts_params, ut_params, reference, 0);
14091 }
14092
14093 static int
14094 test_authentication_verify_GMAC_fail_when_data_corrupted(
14095                 struct crypto_testsuite_params *ts_params,
14096                 struct crypto_unittest_params *ut_params,
14097                 const struct test_crypto_vector *reference)
14098 {
14099         return test_authentication_verify_GMAC_fail_when_corruption(
14100                         ts_params, ut_params, reference, 1);
14101 }
14102
14103 static int
14104 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14105                 struct crypto_testsuite_params *ts_params,
14106                 struct crypto_unittest_params *ut_params,
14107                 const struct test_crypto_vector *reference)
14108 {
14109         return test_authentication_verify_GMAC_fail_when_corruption(
14110                         ts_params, ut_params, reference, 0);
14111 }
14112
14113 static int
14114 test_authenticated_decryption_fail_when_data_corrupted(
14115                 struct crypto_testsuite_params *ts_params,
14116                 struct crypto_unittest_params *ut_params,
14117                 const struct test_crypto_vector *reference)
14118 {
14119         return test_authenticated_decryption_fail_when_corruption(
14120                         ts_params, ut_params, reference, 1);
14121 }
14122
14123 static int
14124 test_authenticated_decryption_fail_when_tag_corrupted(
14125                 struct crypto_testsuite_params *ts_params,
14126                 struct crypto_unittest_params *ut_params,
14127                 const struct test_crypto_vector *reference)
14128 {
14129         return test_authenticated_decryption_fail_when_corruption(
14130                         ts_params, ut_params, reference, 0);
14131 }
14132
14133 static int
14134 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14135 {
14136         return test_authentication_verify_fail_when_data_corrupted(
14137                         &testsuite_params, &unittest_params,
14138                         &hmac_sha1_test_crypto_vector);
14139 }
14140
14141 static int
14142 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14143 {
14144         return test_authentication_verify_fail_when_tag_corrupted(
14145                         &testsuite_params, &unittest_params,
14146                         &hmac_sha1_test_crypto_vector);
14147 }
14148
14149 static int
14150 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14151 {
14152         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14153                         &testsuite_params, &unittest_params,
14154                         &aes128_gmac_test_vector);
14155 }
14156
14157 static int
14158 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14159 {
14160         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14161                         &testsuite_params, &unittest_params,
14162                         &aes128_gmac_test_vector);
14163 }
14164
14165 static int
14166 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14167 {
14168         return test_authenticated_decryption_fail_when_data_corrupted(
14169                         &testsuite_params,
14170                         &unittest_params,
14171                         &aes128cbc_hmac_sha1_test_vector);
14172 }
14173
14174 static int
14175 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14176 {
14177         return test_authenticated_decryption_fail_when_tag_corrupted(
14178                         &testsuite_params,
14179                         &unittest_params,
14180                         &aes128cbc_hmac_sha1_test_vector);
14181 }
14182
14183 static int
14184 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14185 {
14186         return test_authenticated_encrypt_with_esn(
14187                         &testsuite_params,
14188                         &unittest_params,
14189                         &aes128cbc_hmac_sha1_aad_test_vector);
14190 }
14191
14192 static int
14193 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14194 {
14195         return test_authenticated_decrypt_with_esn(
14196                         &testsuite_params,
14197                         &unittest_params,
14198                         &aes128cbc_hmac_sha1_aad_test_vector);
14199 }
14200
14201 static int
14202 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14203 {
14204         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14205 }
14206
14207 static int
14208 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14209 {
14210         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14211 }
14212
14213 static int
14214 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14215 {
14216         return test_authenticated_encryption_SGL(
14217                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14218                 chacha20_poly1305_case_2.plaintext.len);
14219 }
14220
14221 #ifdef RTE_CRYPTO_SCHEDULER
14222
14223 /* global AESNI worker IDs for the scheduler test */
14224 uint8_t aesni_ids[2];
14225
14226 static int
14227 scheduler_testsuite_setup(void)
14228 {
14229         uint32_t i = 0;
14230         int32_t nb_devs, ret;
14231         char vdev_args[VDEV_ARGS_SIZE] = {""};
14232         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14233                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14234         uint16_t worker_core_count = 0;
14235         uint16_t socket_id = 0;
14236
14237         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14238                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14239
14240                 /* Identify the Worker Cores
14241                  * Use 2 worker cores for the device args
14242                  */
14243                 RTE_LCORE_FOREACH_WORKER(i) {
14244                         if (worker_core_count > 1)
14245                                 break;
14246                         snprintf(vdev_args, sizeof(vdev_args),
14247                                         "%s%d", temp_str, i);
14248                         strcpy(temp_str, vdev_args);
14249                         strlcat(temp_str, ";", sizeof(temp_str));
14250                         worker_core_count++;
14251                         socket_id = rte_lcore_to_socket_id(i);
14252                 }
14253                 if (worker_core_count != 2) {
14254                         RTE_LOG(ERR, USER1,
14255                                 "Cryptodev scheduler test require at least "
14256                                 "two worker cores to run. "
14257                                 "Please use the correct coremask.\n");
14258                         return TEST_FAILED;
14259                 }
14260                 strcpy(temp_str, vdev_args);
14261                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14262                                 temp_str, socket_id);
14263                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14264                 nb_devs = rte_cryptodev_device_count_by_driver(
14265                                 rte_cryptodev_driver_id_get(
14266                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14267                 if (nb_devs < 1) {
14268                         ret = rte_vdev_init(
14269                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14270                                         vdev_args);
14271                         TEST_ASSERT(ret == 0,
14272                                 "Failed to create instance %u of pmd : %s",
14273                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14274                 }
14275         }
14276         return testsuite_setup();
14277 }
14278
14279 static int
14280 test_scheduler_attach_worker_op(void)
14281 {
14282         struct crypto_testsuite_params *ts_params = &testsuite_params;
14283         uint8_t sched_id = ts_params->valid_devs[0];
14284         uint32_t i, nb_devs_attached = 0;
14285         int ret;
14286         char vdev_name[32];
14287         unsigned int count = rte_cryptodev_count();
14288
14289         /* create 2 AESNI_MB vdevs on top of existing devices */
14290         for (i = count; i < count + 2; i++) {
14291                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14292                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14293                                 i);
14294                 ret = rte_vdev_init(vdev_name, NULL);
14295
14296                 TEST_ASSERT(ret == 0,
14297                         "Failed to create instance %u of"
14298                         " pmd : %s",
14299                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14300
14301                 if (ret < 0) {
14302                         RTE_LOG(ERR, USER1,
14303                                 "Failed to create 2 AESNI MB PMDs.\n");
14304                         return TEST_SKIPPED;
14305                 }
14306         }
14307
14308         /* attach 2 AESNI_MB cdevs */
14309         for (i = count; i < count + 2; i++) {
14310                 struct rte_cryptodev_info info;
14311                 unsigned int session_size;
14312
14313                 rte_cryptodev_info_get(i, &info);
14314                 if (info.driver_id != rte_cryptodev_driver_id_get(
14315                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14316                         continue;
14317
14318                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14319                 /*
14320                  * Create the session mempool again, since now there are new devices
14321                  * to use the mempool.
14322                  */
14323                 if (ts_params->session_mpool) {
14324                         rte_mempool_free(ts_params->session_mpool);
14325                         ts_params->session_mpool = NULL;
14326                 }
14327                 if (ts_params->session_priv_mpool) {
14328                         rte_mempool_free(ts_params->session_priv_mpool);
14329                         ts_params->session_priv_mpool = NULL;
14330                 }
14331
14332                 if (info.sym.max_nb_sessions != 0 &&
14333                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14334                         RTE_LOG(ERR, USER1,
14335                                         "Device does not support "
14336                                         "at least %u sessions\n",
14337                                         MAX_NB_SESSIONS);
14338                         return TEST_FAILED;
14339                 }
14340                 /*
14341                  * Create mempool with maximum number of sessions,
14342                  * to include the session headers
14343                  */
14344                 if (ts_params->session_mpool == NULL) {
14345                         ts_params->session_mpool =
14346                                 rte_cryptodev_sym_session_pool_create(
14347                                                 "test_sess_mp",
14348                                                 MAX_NB_SESSIONS, 0, 0, 0,
14349                                                 SOCKET_ID_ANY);
14350                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14351                                         "session mempool allocation failed");
14352                 }
14353
14354                 /*
14355                  * Create mempool with maximum number of sessions,
14356                  * to include device specific session private data
14357                  */
14358                 if (ts_params->session_priv_mpool == NULL) {
14359                         ts_params->session_priv_mpool = rte_mempool_create(
14360                                         "test_sess_mp_priv",
14361                                         MAX_NB_SESSIONS,
14362                                         session_size,
14363                                         0, 0, NULL, NULL, NULL,
14364                                         NULL, SOCKET_ID_ANY,
14365                                         0);
14366
14367                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14368                                         "session mempool allocation failed");
14369                 }
14370
14371                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14372                 ts_params->qp_conf.mp_session_private =
14373                                 ts_params->session_priv_mpool;
14374
14375                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14376                                 (uint8_t)i);
14377
14378                 TEST_ASSERT(ret == 0,
14379                         "Failed to attach device %u of pmd : %s", i,
14380                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14381
14382                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14383
14384                 nb_devs_attached++;
14385         }
14386
14387         return 0;
14388 }
14389
14390 static int
14391 test_scheduler_detach_worker_op(void)
14392 {
14393         struct crypto_testsuite_params *ts_params = &testsuite_params;
14394         uint8_t sched_id = ts_params->valid_devs[0];
14395         uint32_t i;
14396         int ret;
14397
14398         for (i = 0; i < 2; i++) {
14399                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14400                                 aesni_ids[i]);
14401                 TEST_ASSERT(ret == 0,
14402                         "Failed to detach device %u", aesni_ids[i]);
14403         }
14404
14405         return 0;
14406 }
14407
14408 static int
14409 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14410 {
14411         struct crypto_testsuite_params *ts_params = &testsuite_params;
14412         uint8_t sched_id = ts_params->valid_devs[0];
14413         /* set mode */
14414         return rte_cryptodev_scheduler_mode_set(sched_id,
14415                 scheduler_mode);
14416 }
14417
14418 static int
14419 test_scheduler_mode_roundrobin_op(void)
14420 {
14421         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14422                         0, "Failed to set roundrobin mode");
14423         return 0;
14424
14425 }
14426
14427 static int
14428 test_scheduler_mode_multicore_op(void)
14429 {
14430         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14431                         0, "Failed to set multicore mode");
14432
14433         return 0;
14434 }
14435
14436 static int
14437 test_scheduler_mode_failover_op(void)
14438 {
14439         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14440                         0, "Failed to set failover mode");
14441
14442         return 0;
14443 }
14444
14445 static int
14446 test_scheduler_mode_pkt_size_distr_op(void)
14447 {
14448         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14449                         0, "Failed to set pktsize mode");
14450
14451         return 0;
14452 }
14453
14454 static int
14455 scheduler_multicore_testsuite_setup(void)
14456 {
14457         if (test_scheduler_attach_worker_op() < 0)
14458                 return TEST_SKIPPED;
14459         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14460                 return TEST_SKIPPED;
14461         return 0;
14462 }
14463
14464 static int
14465 scheduler_roundrobin_testsuite_setup(void)
14466 {
14467         if (test_scheduler_attach_worker_op() < 0)
14468                 return TEST_SKIPPED;
14469         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14470                 return TEST_SKIPPED;
14471         return 0;
14472 }
14473
14474 static int
14475 scheduler_failover_testsuite_setup(void)
14476 {
14477         if (test_scheduler_attach_worker_op() < 0)
14478                 return TEST_SKIPPED;
14479         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14480                 return TEST_SKIPPED;
14481         return 0;
14482 }
14483
14484 static int
14485 scheduler_pkt_size_distr_testsuite_setup(void)
14486 {
14487         if (test_scheduler_attach_worker_op() < 0)
14488                 return TEST_SKIPPED;
14489         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14490                 return TEST_SKIPPED;
14491         return 0;
14492 }
14493
14494 static void
14495 scheduler_mode_testsuite_teardown(void)
14496 {
14497         test_scheduler_detach_worker_op();
14498 }
14499
14500 #endif /* RTE_CRYPTO_SCHEDULER */
14501
14502 static struct unit_test_suite end_testsuite = {
14503         .suite_name = NULL,
14504         .setup = NULL,
14505         .teardown = NULL,
14506         .unit_test_suites = NULL
14507 };
14508
14509 #ifdef RTE_LIB_SECURITY
14510 static struct unit_test_suite ipsec_proto_testsuite  = {
14511         .suite_name = "IPsec Proto Unit Test Suite",
14512         .setup = ipsec_proto_testsuite_setup,
14513         .unit_test_cases = {
14514                 TEST_CASE_NAMED_WITH_DATA(
14515                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14516                         ut_setup_security, ut_teardown,
14517                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14518                 TEST_CASE_NAMED_WITH_DATA(
14519                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14520                         ut_setup_security, ut_teardown,
14521                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14522                 TEST_CASE_NAMED_WITH_DATA(
14523                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14524                         ut_setup_security, ut_teardown,
14525                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14526                 TEST_CASE_NAMED_WITH_DATA(
14527                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14528                         ut_setup_security, ut_teardown,
14529                         test_ipsec_proto_known_vec,
14530                         &pkt_aes_128_cbc_hmac_sha256),
14531                 TEST_CASE_NAMED_WITH_DATA(
14532                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14533                         ut_setup_security, ut_teardown,
14534                         test_ipsec_proto_known_vec,
14535                         &pkt_aes_128_cbc_hmac_sha384),
14536                 TEST_CASE_NAMED_WITH_DATA(
14537                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14538                         ut_setup_security, ut_teardown,
14539                         test_ipsec_proto_known_vec,
14540                         &pkt_aes_128_cbc_hmac_sha512),
14541                 TEST_CASE_NAMED_WITH_DATA(
14542                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14543                         ut_setup_security, ut_teardown,
14544                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
14545                 TEST_CASE_NAMED_WITH_DATA(
14546                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14547                         ut_setup_security, ut_teardown,
14548                         test_ipsec_proto_known_vec,
14549                         &pkt_aes_128_cbc_hmac_sha256_v6),
14550                 TEST_CASE_NAMED_WITH_DATA(
14551                         "Outbound fragmented packet",
14552                         ut_setup_security, ut_teardown,
14553                         test_ipsec_proto_known_vec_fragmented,
14554                         &pkt_aes_128_gcm_frag),
14555                 TEST_CASE_NAMED_WITH_DATA(
14556                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14557                         ut_setup_security, ut_teardown,
14558                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14559                 TEST_CASE_NAMED_WITH_DATA(
14560                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14561                         ut_setup_security, ut_teardown,
14562                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14563                 TEST_CASE_NAMED_WITH_DATA(
14564                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14565                         ut_setup_security, ut_teardown,
14566                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14567                 TEST_CASE_NAMED_WITH_DATA(
14568                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
14569                         ut_setup_security, ut_teardown,
14570                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
14571                 TEST_CASE_NAMED_WITH_DATA(
14572                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14573                         ut_setup_security, ut_teardown,
14574                         test_ipsec_proto_known_vec_inb,
14575                         &pkt_aes_128_cbc_hmac_sha256),
14576                 TEST_CASE_NAMED_WITH_DATA(
14577                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14578                         ut_setup_security, ut_teardown,
14579                         test_ipsec_proto_known_vec_inb,
14580                         &pkt_aes_128_cbc_hmac_sha384),
14581                 TEST_CASE_NAMED_WITH_DATA(
14582                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14583                         ut_setup_security, ut_teardown,
14584                         test_ipsec_proto_known_vec_inb,
14585                         &pkt_aes_128_cbc_hmac_sha512),
14586                 TEST_CASE_NAMED_WITH_DATA(
14587                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14588                         ut_setup_security, ut_teardown,
14589                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
14590                 TEST_CASE_NAMED_WITH_DATA(
14591                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14592                         ut_setup_security, ut_teardown,
14593                         test_ipsec_proto_known_vec_inb,
14594                         &pkt_aes_128_cbc_hmac_sha256_v6),
14595                 TEST_CASE_NAMED_ST(
14596                         "Combined test alg list",
14597                         ut_setup_security, ut_teardown,
14598                         test_ipsec_proto_display_list),
14599                 TEST_CASE_NAMED_ST(
14600                         "IV generation",
14601                         ut_setup_security, ut_teardown,
14602                         test_ipsec_proto_iv_gen),
14603                 TEST_CASE_NAMED_ST(
14604                         "UDP encapsulation",
14605                         ut_setup_security, ut_teardown,
14606                         test_ipsec_proto_udp_encap),
14607                 TEST_CASE_NAMED_ST(
14608                         "UDP encapsulation ports verification test",
14609                         ut_setup_security, ut_teardown,
14610                         test_ipsec_proto_udp_ports_verify),
14611                 TEST_CASE_NAMED_ST(
14612                         "SA expiry packets soft",
14613                         ut_setup_security, ut_teardown,
14614                         test_ipsec_proto_sa_exp_pkts_soft),
14615                 TEST_CASE_NAMED_ST(
14616                         "SA expiry packets hard",
14617                         ut_setup_security, ut_teardown,
14618                         test_ipsec_proto_sa_exp_pkts_hard),
14619                 TEST_CASE_NAMED_ST(
14620                         "Negative test: ICV corruption",
14621                         ut_setup_security, ut_teardown,
14622                         test_ipsec_proto_err_icv_corrupt),
14623                 TEST_CASE_NAMED_ST(
14624                         "Tunnel dst addr verification",
14625                         ut_setup_security, ut_teardown,
14626                         test_ipsec_proto_tunnel_dst_addr_verify),
14627                 TEST_CASE_NAMED_ST(
14628                         "Tunnel src and dst addr verification",
14629                         ut_setup_security, ut_teardown,
14630                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14631                 TEST_CASE_NAMED_ST(
14632                         "Inner IP checksum",
14633                         ut_setup_security, ut_teardown,
14634                         test_ipsec_proto_inner_ip_csum),
14635                 TEST_CASE_NAMED_ST(
14636                         "Inner L4 checksum",
14637                         ut_setup_security, ut_teardown,
14638                         test_ipsec_proto_inner_l4_csum),
14639                 TEST_CASE_NAMED_ST(
14640                         "Tunnel IPv4 in IPv4",
14641                         ut_setup_security, ut_teardown,
14642                         test_ipsec_proto_tunnel_v4_in_v4),
14643                 TEST_CASE_NAMED_ST(
14644                         "Tunnel IPv6 in IPv6",
14645                         ut_setup_security, ut_teardown,
14646                         test_ipsec_proto_tunnel_v6_in_v6),
14647                 TEST_CASE_NAMED_ST(
14648                         "Tunnel IPv4 in IPv6",
14649                         ut_setup_security, ut_teardown,
14650                         test_ipsec_proto_tunnel_v4_in_v6),
14651                 TEST_CASE_NAMED_ST(
14652                         "Tunnel IPv6 in IPv4",
14653                         ut_setup_security, ut_teardown,
14654                         test_ipsec_proto_tunnel_v6_in_v4),
14655                 TEST_CASE_NAMED_ST(
14656                         "Transport IPv4",
14657                         ut_setup_security, ut_teardown,
14658                         test_ipsec_proto_transport_v4),
14659                 TEST_CASES_END() /**< NULL terminate unit test array */
14660         }
14661 };
14662
14663 static struct unit_test_suite pdcp_proto_testsuite  = {
14664         .suite_name = "PDCP Proto Unit Test Suite",
14665         .setup = pdcp_proto_testsuite_setup,
14666         .unit_test_cases = {
14667                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14668                         test_PDCP_PROTO_all),
14669                 TEST_CASES_END() /**< NULL terminate unit test array */
14670         }
14671 };
14672
14673 #define ADD_UPLINK_TESTCASE(data)                                               \
14674         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
14675         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
14676
14677 #define ADD_DOWNLINK_TESTCASE(data)                                             \
14678         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
14679         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
14680
14681 static struct unit_test_suite docsis_proto_testsuite  = {
14682         .suite_name = "DOCSIS Proto Unit Test Suite",
14683         .setup = docsis_proto_testsuite_setup,
14684         .unit_test_cases = {
14685                 /* Uplink */
14686                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
14687                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
14688                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
14689                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
14690                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
14691                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
14692                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
14693                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
14694                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
14695                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
14696                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
14697                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
14698                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
14699                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
14700                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
14701                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
14702                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
14703                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
14704                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
14705                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
14706                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
14707                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
14708                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
14709                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
14710                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
14711                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
14712                 /* Downlink */
14713                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
14714                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
14715                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
14716                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
14717                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
14718                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
14719                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
14720                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
14721                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
14722                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
14723                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
14724                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
14725                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
14726                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
14727                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
14728                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
14729                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
14730                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
14731                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
14732                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
14733                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
14734                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
14735                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
14736                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
14737                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
14738                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
14739                 TEST_CASES_END() /**< NULL terminate unit test array */
14740         }
14741 };
14742 #endif
14743
14744 static struct unit_test_suite cryptodev_gen_testsuite  = {
14745         .suite_name = "Crypto General Unit Test Suite",
14746         .setup = crypto_gen_testsuite_setup,
14747         .unit_test_cases = {
14748                 TEST_CASE_ST(ut_setup, ut_teardown,
14749                                 test_device_configure_invalid_dev_id),
14750                 TEST_CASE_ST(ut_setup, ut_teardown,
14751                                 test_queue_pair_descriptor_setup),
14752                 TEST_CASE_ST(ut_setup, ut_teardown,
14753                                 test_device_configure_invalid_queue_pair_ids),
14754                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
14755                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
14756                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
14757                 TEST_CASES_END() /**< NULL terminate unit test array */
14758         }
14759 };
14760
14761 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
14762         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
14763         .setup = negative_hmac_sha1_testsuite_setup,
14764         .unit_test_cases = {
14765                 /** Negative tests */
14766                 TEST_CASE_ST(ut_setup, ut_teardown,
14767                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
14768                 TEST_CASE_ST(ut_setup, ut_teardown,
14769                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
14770                 TEST_CASE_ST(ut_setup, ut_teardown,
14771                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
14772                 TEST_CASE_ST(ut_setup, ut_teardown,
14773                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
14774
14775                 TEST_CASES_END() /**< NULL terminate unit test array */
14776         }
14777 };
14778
14779 static struct unit_test_suite cryptodev_multi_session_testsuite = {
14780         .suite_name = "Multi Session Unit Test Suite",
14781         .setup = multi_session_testsuite_setup,
14782         .unit_test_cases = {
14783                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
14784                 TEST_CASE_ST(ut_setup, ut_teardown,
14785                                 test_multi_session_random_usage),
14786
14787                 TEST_CASES_END() /**< NULL terminate unit test array */
14788         }
14789 };
14790
14791 static struct unit_test_suite cryptodev_null_testsuite  = {
14792         .suite_name = "NULL Test Suite",
14793         .setup = null_testsuite_setup,
14794         .unit_test_cases = {
14795                 TEST_CASE_ST(ut_setup, ut_teardown,
14796                         test_null_invalid_operation),
14797                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
14798                 TEST_CASES_END()
14799         }
14800 };
14801
14802 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
14803         .suite_name = "AES CCM Authenticated Test Suite",
14804         .setup = aes_ccm_auth_testsuite_setup,
14805         .unit_test_cases = {
14806                 /** AES CCM Authenticated Encryption 128 bits key*/
14807                 TEST_CASE_ST(ut_setup, ut_teardown,
14808                         test_AES_CCM_authenticated_encryption_test_case_128_1),
14809                 TEST_CASE_ST(ut_setup, ut_teardown,
14810                         test_AES_CCM_authenticated_encryption_test_case_128_2),
14811                 TEST_CASE_ST(ut_setup, ut_teardown,
14812                         test_AES_CCM_authenticated_encryption_test_case_128_3),
14813
14814                 /** AES CCM Authenticated Decryption 128 bits key*/
14815                 TEST_CASE_ST(ut_setup, ut_teardown,
14816                         test_AES_CCM_authenticated_decryption_test_case_128_1),
14817                 TEST_CASE_ST(ut_setup, ut_teardown,
14818                         test_AES_CCM_authenticated_decryption_test_case_128_2),
14819                 TEST_CASE_ST(ut_setup, ut_teardown,
14820                         test_AES_CCM_authenticated_decryption_test_case_128_3),
14821
14822                 /** AES CCM Authenticated Encryption 192 bits key */
14823                 TEST_CASE_ST(ut_setup, ut_teardown,
14824                         test_AES_CCM_authenticated_encryption_test_case_192_1),
14825                 TEST_CASE_ST(ut_setup, ut_teardown,
14826                         test_AES_CCM_authenticated_encryption_test_case_192_2),
14827                 TEST_CASE_ST(ut_setup, ut_teardown,
14828                         test_AES_CCM_authenticated_encryption_test_case_192_3),
14829
14830                 /** AES CCM Authenticated Decryption 192 bits key*/
14831                 TEST_CASE_ST(ut_setup, ut_teardown,
14832                         test_AES_CCM_authenticated_decryption_test_case_192_1),
14833                 TEST_CASE_ST(ut_setup, ut_teardown,
14834                         test_AES_CCM_authenticated_decryption_test_case_192_2),
14835                 TEST_CASE_ST(ut_setup, ut_teardown,
14836                         test_AES_CCM_authenticated_decryption_test_case_192_3),
14837
14838                 /** AES CCM Authenticated Encryption 256 bits key */
14839                 TEST_CASE_ST(ut_setup, ut_teardown,
14840                         test_AES_CCM_authenticated_encryption_test_case_256_1),
14841                 TEST_CASE_ST(ut_setup, ut_teardown,
14842                         test_AES_CCM_authenticated_encryption_test_case_256_2),
14843                 TEST_CASE_ST(ut_setup, ut_teardown,
14844                         test_AES_CCM_authenticated_encryption_test_case_256_3),
14845
14846                 /** AES CCM Authenticated Decryption 256 bits key*/
14847                 TEST_CASE_ST(ut_setup, ut_teardown,
14848                         test_AES_CCM_authenticated_decryption_test_case_256_1),
14849                 TEST_CASE_ST(ut_setup, ut_teardown,
14850                         test_AES_CCM_authenticated_decryption_test_case_256_2),
14851                 TEST_CASE_ST(ut_setup, ut_teardown,
14852                         test_AES_CCM_authenticated_decryption_test_case_256_3),
14853                 TEST_CASES_END()
14854         }
14855 };
14856
14857 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
14858         .suite_name = "AES GCM Authenticated Test Suite",
14859         .setup = aes_gcm_auth_testsuite_setup,
14860         .unit_test_cases = {
14861                 /** AES GCM Authenticated Encryption */
14862                 TEST_CASE_ST(ut_setup, ut_teardown,
14863                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
14864                 TEST_CASE_ST(ut_setup, ut_teardown,
14865                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
14866                 TEST_CASE_ST(ut_setup, ut_teardown,
14867                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
14868                 TEST_CASE_ST(ut_setup, ut_teardown,
14869                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
14870                 TEST_CASE_ST(ut_setup, ut_teardown,
14871                         test_AES_GCM_authenticated_encryption_test_case_1),
14872                 TEST_CASE_ST(ut_setup, ut_teardown,
14873                         test_AES_GCM_authenticated_encryption_test_case_2),
14874                 TEST_CASE_ST(ut_setup, ut_teardown,
14875                         test_AES_GCM_authenticated_encryption_test_case_3),
14876                 TEST_CASE_ST(ut_setup, ut_teardown,
14877                         test_AES_GCM_authenticated_encryption_test_case_4),
14878                 TEST_CASE_ST(ut_setup, ut_teardown,
14879                         test_AES_GCM_authenticated_encryption_test_case_5),
14880                 TEST_CASE_ST(ut_setup, ut_teardown,
14881                         test_AES_GCM_authenticated_encryption_test_case_6),
14882                 TEST_CASE_ST(ut_setup, ut_teardown,
14883                         test_AES_GCM_authenticated_encryption_test_case_7),
14884                 TEST_CASE_ST(ut_setup, ut_teardown,
14885                         test_AES_GCM_authenticated_encryption_test_case_8),
14886                 TEST_CASE_ST(ut_setup, ut_teardown,
14887                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
14888
14889                 /** AES GCM Authenticated Decryption */
14890                 TEST_CASE_ST(ut_setup, ut_teardown,
14891                         test_AES_GCM_authenticated_decryption_test_case_1),
14892                 TEST_CASE_ST(ut_setup, ut_teardown,
14893                         test_AES_GCM_authenticated_decryption_test_case_2),
14894                 TEST_CASE_ST(ut_setup, ut_teardown,
14895                         test_AES_GCM_authenticated_decryption_test_case_3),
14896                 TEST_CASE_ST(ut_setup, ut_teardown,
14897                         test_AES_GCM_authenticated_decryption_test_case_4),
14898                 TEST_CASE_ST(ut_setup, ut_teardown,
14899                         test_AES_GCM_authenticated_decryption_test_case_5),
14900                 TEST_CASE_ST(ut_setup, ut_teardown,
14901                         test_AES_GCM_authenticated_decryption_test_case_6),
14902                 TEST_CASE_ST(ut_setup, ut_teardown,
14903                         test_AES_GCM_authenticated_decryption_test_case_7),
14904                 TEST_CASE_ST(ut_setup, ut_teardown,
14905                         test_AES_GCM_authenticated_decryption_test_case_8),
14906                 TEST_CASE_ST(ut_setup, ut_teardown,
14907                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
14908
14909                 /** AES GCM Authenticated Encryption 192 bits key */
14910                 TEST_CASE_ST(ut_setup, ut_teardown,
14911                         test_AES_GCM_auth_encryption_test_case_192_1),
14912                 TEST_CASE_ST(ut_setup, ut_teardown,
14913                         test_AES_GCM_auth_encryption_test_case_192_2),
14914                 TEST_CASE_ST(ut_setup, ut_teardown,
14915                         test_AES_GCM_auth_encryption_test_case_192_3),
14916                 TEST_CASE_ST(ut_setup, ut_teardown,
14917                         test_AES_GCM_auth_encryption_test_case_192_4),
14918                 TEST_CASE_ST(ut_setup, ut_teardown,
14919                         test_AES_GCM_auth_encryption_test_case_192_5),
14920                 TEST_CASE_ST(ut_setup, ut_teardown,
14921                         test_AES_GCM_auth_encryption_test_case_192_6),
14922                 TEST_CASE_ST(ut_setup, ut_teardown,
14923                         test_AES_GCM_auth_encryption_test_case_192_7),
14924
14925                 /** AES GCM Authenticated Decryption 192 bits key */
14926                 TEST_CASE_ST(ut_setup, ut_teardown,
14927                         test_AES_GCM_auth_decryption_test_case_192_1),
14928                 TEST_CASE_ST(ut_setup, ut_teardown,
14929                         test_AES_GCM_auth_decryption_test_case_192_2),
14930                 TEST_CASE_ST(ut_setup, ut_teardown,
14931                         test_AES_GCM_auth_decryption_test_case_192_3),
14932                 TEST_CASE_ST(ut_setup, ut_teardown,
14933                         test_AES_GCM_auth_decryption_test_case_192_4),
14934                 TEST_CASE_ST(ut_setup, ut_teardown,
14935                         test_AES_GCM_auth_decryption_test_case_192_5),
14936                 TEST_CASE_ST(ut_setup, ut_teardown,
14937                         test_AES_GCM_auth_decryption_test_case_192_6),
14938                 TEST_CASE_ST(ut_setup, ut_teardown,
14939                         test_AES_GCM_auth_decryption_test_case_192_7),
14940
14941                 /** AES GCM Authenticated Encryption 256 bits key */
14942                 TEST_CASE_ST(ut_setup, ut_teardown,
14943                         test_AES_GCM_auth_encryption_test_case_256_1),
14944                 TEST_CASE_ST(ut_setup, ut_teardown,
14945                         test_AES_GCM_auth_encryption_test_case_256_2),
14946                 TEST_CASE_ST(ut_setup, ut_teardown,
14947                         test_AES_GCM_auth_encryption_test_case_256_3),
14948                 TEST_CASE_ST(ut_setup, ut_teardown,
14949                         test_AES_GCM_auth_encryption_test_case_256_4),
14950                 TEST_CASE_ST(ut_setup, ut_teardown,
14951                         test_AES_GCM_auth_encryption_test_case_256_5),
14952                 TEST_CASE_ST(ut_setup, ut_teardown,
14953                         test_AES_GCM_auth_encryption_test_case_256_6),
14954                 TEST_CASE_ST(ut_setup, ut_teardown,
14955                         test_AES_GCM_auth_encryption_test_case_256_7),
14956
14957                 /** AES GCM Authenticated Decryption 256 bits key */
14958                 TEST_CASE_ST(ut_setup, ut_teardown,
14959                         test_AES_GCM_auth_decryption_test_case_256_1),
14960                 TEST_CASE_ST(ut_setup, ut_teardown,
14961                         test_AES_GCM_auth_decryption_test_case_256_2),
14962                 TEST_CASE_ST(ut_setup, ut_teardown,
14963                         test_AES_GCM_auth_decryption_test_case_256_3),
14964                 TEST_CASE_ST(ut_setup, ut_teardown,
14965                         test_AES_GCM_auth_decryption_test_case_256_4),
14966                 TEST_CASE_ST(ut_setup, ut_teardown,
14967                         test_AES_GCM_auth_decryption_test_case_256_5),
14968                 TEST_CASE_ST(ut_setup, ut_teardown,
14969                         test_AES_GCM_auth_decryption_test_case_256_6),
14970                 TEST_CASE_ST(ut_setup, ut_teardown,
14971                         test_AES_GCM_auth_decryption_test_case_256_7),
14972
14973                 /** AES GCM Authenticated Encryption big aad size */
14974                 TEST_CASE_ST(ut_setup, ut_teardown,
14975                         test_AES_GCM_auth_encryption_test_case_aad_1),
14976                 TEST_CASE_ST(ut_setup, ut_teardown,
14977                         test_AES_GCM_auth_encryption_test_case_aad_2),
14978
14979                 /** AES GCM Authenticated Decryption big aad size */
14980                 TEST_CASE_ST(ut_setup, ut_teardown,
14981                         test_AES_GCM_auth_decryption_test_case_aad_1),
14982                 TEST_CASE_ST(ut_setup, ut_teardown,
14983                         test_AES_GCM_auth_decryption_test_case_aad_2),
14984
14985                 /** Out of place tests */
14986                 TEST_CASE_ST(ut_setup, ut_teardown,
14987                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
14988                 TEST_CASE_ST(ut_setup, ut_teardown,
14989                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
14990
14991                 /** Session-less tests */
14992                 TEST_CASE_ST(ut_setup, ut_teardown,
14993                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
14994                 TEST_CASE_ST(ut_setup, ut_teardown,
14995                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
14996
14997                 TEST_CASES_END()
14998         }
14999 };
15000
15001 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15002         .suite_name = "AES GMAC Authentication Test Suite",
15003         .setup = aes_gmac_auth_testsuite_setup,
15004         .unit_test_cases = {
15005                 TEST_CASE_ST(ut_setup, ut_teardown,
15006                         test_AES_GMAC_authentication_test_case_1),
15007                 TEST_CASE_ST(ut_setup, ut_teardown,
15008                         test_AES_GMAC_authentication_verify_test_case_1),
15009                 TEST_CASE_ST(ut_setup, ut_teardown,
15010                         test_AES_GMAC_authentication_test_case_2),
15011                 TEST_CASE_ST(ut_setup, ut_teardown,
15012                         test_AES_GMAC_authentication_verify_test_case_2),
15013                 TEST_CASE_ST(ut_setup, ut_teardown,
15014                         test_AES_GMAC_authentication_test_case_3),
15015                 TEST_CASE_ST(ut_setup, ut_teardown,
15016                         test_AES_GMAC_authentication_verify_test_case_3),
15017                 TEST_CASE_ST(ut_setup, ut_teardown,
15018                         test_AES_GMAC_authentication_test_case_4),
15019                 TEST_CASE_ST(ut_setup, ut_teardown,
15020                         test_AES_GMAC_authentication_verify_test_case_4),
15021                 TEST_CASE_ST(ut_setup, ut_teardown,
15022                         test_AES_GMAC_authentication_SGL_40B),
15023                 TEST_CASE_ST(ut_setup, ut_teardown,
15024                         test_AES_GMAC_authentication_SGL_80B),
15025                 TEST_CASE_ST(ut_setup, ut_teardown,
15026                         test_AES_GMAC_authentication_SGL_2048B),
15027                 TEST_CASE_ST(ut_setup, ut_teardown,
15028                         test_AES_GMAC_authentication_SGL_2047B),
15029
15030                 TEST_CASES_END()
15031         }
15032 };
15033
15034 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15035         .suite_name = "Chacha20-Poly1305 Test Suite",
15036         .setup = chacha20_poly1305_testsuite_setup,
15037         .unit_test_cases = {
15038                 TEST_CASE_ST(ut_setup, ut_teardown,
15039                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15040                 TEST_CASE_ST(ut_setup, ut_teardown,
15041                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15042                 TEST_CASE_ST(ut_setup, ut_teardown,
15043                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15044                 TEST_CASES_END()
15045         }
15046 };
15047
15048 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15049         .suite_name = "SNOW 3G Test Suite",
15050         .setup = snow3g_testsuite_setup,
15051         .unit_test_cases = {
15052                 /** SNOW 3G encrypt only (UEA2) */
15053                 TEST_CASE_ST(ut_setup, ut_teardown,
15054                         test_snow3g_encryption_test_case_1),
15055                 TEST_CASE_ST(ut_setup, ut_teardown,
15056                         test_snow3g_encryption_test_case_2),
15057                 TEST_CASE_ST(ut_setup, ut_teardown,
15058                         test_snow3g_encryption_test_case_3),
15059                 TEST_CASE_ST(ut_setup, ut_teardown,
15060                         test_snow3g_encryption_test_case_4),
15061                 TEST_CASE_ST(ut_setup, ut_teardown,
15062                         test_snow3g_encryption_test_case_5),
15063
15064                 TEST_CASE_ST(ut_setup, ut_teardown,
15065                         test_snow3g_encryption_test_case_1_oop),
15066                 TEST_CASE_ST(ut_setup, ut_teardown,
15067                         test_snow3g_encryption_test_case_1_oop_sgl),
15068                 TEST_CASE_ST(ut_setup, ut_teardown,
15069                         test_snow3g_encryption_test_case_1_offset_oop),
15070                 TEST_CASE_ST(ut_setup, ut_teardown,
15071                         test_snow3g_decryption_test_case_1_oop),
15072
15073                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15074                 TEST_CASE_ST(ut_setup, ut_teardown,
15075                         test_snow3g_auth_cipher_test_case_1),
15076                 TEST_CASE_ST(ut_setup, ut_teardown,
15077                         test_snow3g_auth_cipher_test_case_2),
15078                 TEST_CASE_ST(ut_setup, ut_teardown,
15079                         test_snow3g_auth_cipher_test_case_2_oop),
15080                 TEST_CASE_ST(ut_setup, ut_teardown,
15081                         test_snow3g_auth_cipher_part_digest_enc),
15082                 TEST_CASE_ST(ut_setup, ut_teardown,
15083                         test_snow3g_auth_cipher_part_digest_enc_oop),
15084                 TEST_CASE_ST(ut_setup, ut_teardown,
15085                         test_snow3g_auth_cipher_test_case_3_sgl),
15086                 TEST_CASE_ST(ut_setup, ut_teardown,
15087                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15088                 TEST_CASE_ST(ut_setup, ut_teardown,
15089                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15090                 TEST_CASE_ST(ut_setup, ut_teardown,
15091                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15092
15093                 /** SNOW 3G decrypt (UEA2), then verify auth */
15094                 TEST_CASE_ST(ut_setup, ut_teardown,
15095                         test_snow3g_auth_cipher_verify_test_case_1),
15096                 TEST_CASE_ST(ut_setup, ut_teardown,
15097                         test_snow3g_auth_cipher_verify_test_case_2),
15098                 TEST_CASE_ST(ut_setup, ut_teardown,
15099                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15100                 TEST_CASE_ST(ut_setup, ut_teardown,
15101                         test_snow3g_auth_cipher_verify_part_digest_enc),
15102                 TEST_CASE_ST(ut_setup, ut_teardown,
15103                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15104                 TEST_CASE_ST(ut_setup, ut_teardown,
15105                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15106                 TEST_CASE_ST(ut_setup, ut_teardown,
15107                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15108                 TEST_CASE_ST(ut_setup, ut_teardown,
15109                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15110                 TEST_CASE_ST(ut_setup, ut_teardown,
15111                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15112
15113                 /** SNOW 3G decrypt only (UEA2) */
15114                 TEST_CASE_ST(ut_setup, ut_teardown,
15115                         test_snow3g_decryption_test_case_1),
15116                 TEST_CASE_ST(ut_setup, ut_teardown,
15117                         test_snow3g_decryption_test_case_2),
15118                 TEST_CASE_ST(ut_setup, ut_teardown,
15119                         test_snow3g_decryption_test_case_3),
15120                 TEST_CASE_ST(ut_setup, ut_teardown,
15121                         test_snow3g_decryption_test_case_4),
15122                 TEST_CASE_ST(ut_setup, ut_teardown,
15123                         test_snow3g_decryption_test_case_5),
15124                 TEST_CASE_ST(ut_setup, ut_teardown,
15125                         test_snow3g_decryption_with_digest_test_case_1),
15126                 TEST_CASE_ST(ut_setup, ut_teardown,
15127                         test_snow3g_hash_generate_test_case_1),
15128                 TEST_CASE_ST(ut_setup, ut_teardown,
15129                         test_snow3g_hash_generate_test_case_2),
15130                 TEST_CASE_ST(ut_setup, ut_teardown,
15131                         test_snow3g_hash_generate_test_case_3),
15132
15133                 /* Tests with buffers which length is not byte-aligned */
15134                 TEST_CASE_ST(ut_setup, ut_teardown,
15135                         test_snow3g_hash_generate_test_case_4),
15136                 TEST_CASE_ST(ut_setup, ut_teardown,
15137                         test_snow3g_hash_generate_test_case_5),
15138                 TEST_CASE_ST(ut_setup, ut_teardown,
15139                         test_snow3g_hash_generate_test_case_6),
15140                 TEST_CASE_ST(ut_setup, ut_teardown,
15141                         test_snow3g_hash_verify_test_case_1),
15142                 TEST_CASE_ST(ut_setup, ut_teardown,
15143                         test_snow3g_hash_verify_test_case_2),
15144                 TEST_CASE_ST(ut_setup, ut_teardown,
15145                         test_snow3g_hash_verify_test_case_3),
15146
15147                 /* Tests with buffers which length is not byte-aligned */
15148                 TEST_CASE_ST(ut_setup, ut_teardown,
15149                         test_snow3g_hash_verify_test_case_4),
15150                 TEST_CASE_ST(ut_setup, ut_teardown,
15151                         test_snow3g_hash_verify_test_case_5),
15152                 TEST_CASE_ST(ut_setup, ut_teardown,
15153                         test_snow3g_hash_verify_test_case_6),
15154                 TEST_CASE_ST(ut_setup, ut_teardown,
15155                         test_snow3g_cipher_auth_test_case_1),
15156                 TEST_CASE_ST(ut_setup, ut_teardown,
15157                         test_snow3g_auth_cipher_with_digest_test_case_1),
15158                 TEST_CASES_END()
15159         }
15160 };
15161
15162 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15163         .suite_name = "ZUC Test Suite",
15164         .setup = zuc_testsuite_setup,
15165         .unit_test_cases = {
15166                 /** ZUC encrypt only (EEA3) */
15167                 TEST_CASE_ST(ut_setup, ut_teardown,
15168                         test_zuc_encryption_test_case_1),
15169                 TEST_CASE_ST(ut_setup, ut_teardown,
15170                         test_zuc_encryption_test_case_2),
15171                 TEST_CASE_ST(ut_setup, ut_teardown,
15172                         test_zuc_encryption_test_case_3),
15173                 TEST_CASE_ST(ut_setup, ut_teardown,
15174                         test_zuc_encryption_test_case_4),
15175                 TEST_CASE_ST(ut_setup, ut_teardown,
15176                         test_zuc_encryption_test_case_5),
15177                 TEST_CASE_ST(ut_setup, ut_teardown,
15178                         test_zuc_encryption_test_case_6_sgl),
15179
15180                 /** ZUC authenticate (EIA3) */
15181                 TEST_CASE_ST(ut_setup, ut_teardown,
15182                         test_zuc_hash_generate_test_case_1),
15183                 TEST_CASE_ST(ut_setup, ut_teardown,
15184                         test_zuc_hash_generate_test_case_2),
15185                 TEST_CASE_ST(ut_setup, ut_teardown,
15186                         test_zuc_hash_generate_test_case_3),
15187                 TEST_CASE_ST(ut_setup, ut_teardown,
15188                         test_zuc_hash_generate_test_case_4),
15189                 TEST_CASE_ST(ut_setup, ut_teardown,
15190                         test_zuc_hash_generate_test_case_5),
15191                 TEST_CASE_ST(ut_setup, ut_teardown,
15192                         test_zuc_hash_generate_test_case_6),
15193                 TEST_CASE_ST(ut_setup, ut_teardown,
15194                         test_zuc_hash_generate_test_case_7),
15195                 TEST_CASE_ST(ut_setup, ut_teardown,
15196                         test_zuc_hash_generate_test_case_8),
15197                 TEST_CASE_ST(ut_setup, ut_teardown,
15198                         test_zuc_hash_generate_test_case_9),
15199                 TEST_CASE_ST(ut_setup, ut_teardown,
15200                         test_zuc_hash_generate_test_case_10),
15201                 TEST_CASE_ST(ut_setup, ut_teardown,
15202                         test_zuc_hash_generate_test_case_11),
15203
15204
15205                 /** ZUC alg-chain (EEA3/EIA3) */
15206                 TEST_CASE_ST(ut_setup, ut_teardown,
15207                         test_zuc_cipher_auth_test_case_1),
15208                 TEST_CASE_ST(ut_setup, ut_teardown,
15209                         test_zuc_cipher_auth_test_case_2),
15210
15211                 /** ZUC generate auth, then encrypt (EEA3) */
15212                 TEST_CASE_ST(ut_setup, ut_teardown,
15213                         test_zuc_auth_cipher_test_case_1),
15214                 TEST_CASE_ST(ut_setup, ut_teardown,
15215                         test_zuc_auth_cipher_test_case_1_oop),
15216                 TEST_CASE_ST(ut_setup, ut_teardown,
15217                         test_zuc_auth_cipher_test_case_1_sgl),
15218                 TEST_CASE_ST(ut_setup, ut_teardown,
15219                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15220
15221                 /** ZUC decrypt (EEA3), then verify auth */
15222                 TEST_CASE_ST(ut_setup, ut_teardown,
15223                         test_zuc_auth_cipher_verify_test_case_1),
15224                 TEST_CASE_ST(ut_setup, ut_teardown,
15225                         test_zuc_auth_cipher_verify_test_case_1_oop),
15226                 TEST_CASE_ST(ut_setup, ut_teardown,
15227                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15228                 TEST_CASE_ST(ut_setup, ut_teardown,
15229                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15230
15231                 /** ZUC-256 encrypt only **/
15232                 TEST_CASE_ST(ut_setup, ut_teardown,
15233                         test_zuc256_encryption_test_case_1),
15234                 TEST_CASE_ST(ut_setup, ut_teardown,
15235                         test_zuc256_encryption_test_case_2),
15236
15237                 /** ZUC-256 authentication only **/
15238                 TEST_CASE_ST(ut_setup, ut_teardown,
15239                         test_zuc256_authentication_test_case_1),
15240                 TEST_CASE_ST(ut_setup, ut_teardown,
15241                         test_zuc256_authentication_test_case_2),
15242
15243                 TEST_CASES_END()
15244         }
15245 };
15246
15247 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15248         .suite_name = "HMAC_MD5 Authentication Test Suite",
15249         .setup = hmac_md5_auth_testsuite_setup,
15250         .unit_test_cases = {
15251                 TEST_CASE_ST(ut_setup, ut_teardown,
15252                         test_MD5_HMAC_generate_case_1),
15253                 TEST_CASE_ST(ut_setup, ut_teardown,
15254                         test_MD5_HMAC_verify_case_1),
15255                 TEST_CASE_ST(ut_setup, ut_teardown,
15256                         test_MD5_HMAC_generate_case_2),
15257                 TEST_CASE_ST(ut_setup, ut_teardown,
15258                         test_MD5_HMAC_verify_case_2),
15259                 TEST_CASES_END()
15260         }
15261 };
15262
15263 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15264         .suite_name = "Kasumi Test Suite",
15265         .setup = kasumi_testsuite_setup,
15266         .unit_test_cases = {
15267                 /** KASUMI hash only (UIA1) */
15268                 TEST_CASE_ST(ut_setup, ut_teardown,
15269                         test_kasumi_hash_generate_test_case_1),
15270                 TEST_CASE_ST(ut_setup, ut_teardown,
15271                         test_kasumi_hash_generate_test_case_2),
15272                 TEST_CASE_ST(ut_setup, ut_teardown,
15273                         test_kasumi_hash_generate_test_case_3),
15274                 TEST_CASE_ST(ut_setup, ut_teardown,
15275                         test_kasumi_hash_generate_test_case_4),
15276                 TEST_CASE_ST(ut_setup, ut_teardown,
15277                         test_kasumi_hash_generate_test_case_5),
15278                 TEST_CASE_ST(ut_setup, ut_teardown,
15279                         test_kasumi_hash_generate_test_case_6),
15280
15281                 TEST_CASE_ST(ut_setup, ut_teardown,
15282                         test_kasumi_hash_verify_test_case_1),
15283                 TEST_CASE_ST(ut_setup, ut_teardown,
15284                         test_kasumi_hash_verify_test_case_2),
15285                 TEST_CASE_ST(ut_setup, ut_teardown,
15286                         test_kasumi_hash_verify_test_case_3),
15287                 TEST_CASE_ST(ut_setup, ut_teardown,
15288                         test_kasumi_hash_verify_test_case_4),
15289                 TEST_CASE_ST(ut_setup, ut_teardown,
15290                         test_kasumi_hash_verify_test_case_5),
15291
15292                 /** KASUMI encrypt only (UEA1) */
15293                 TEST_CASE_ST(ut_setup, ut_teardown,
15294                         test_kasumi_encryption_test_case_1),
15295                 TEST_CASE_ST(ut_setup, ut_teardown,
15296                         test_kasumi_encryption_test_case_1_sgl),
15297                 TEST_CASE_ST(ut_setup, ut_teardown,
15298                         test_kasumi_encryption_test_case_1_oop),
15299                 TEST_CASE_ST(ut_setup, ut_teardown,
15300                         test_kasumi_encryption_test_case_1_oop_sgl),
15301                 TEST_CASE_ST(ut_setup, ut_teardown,
15302                         test_kasumi_encryption_test_case_2),
15303                 TEST_CASE_ST(ut_setup, ut_teardown,
15304                         test_kasumi_encryption_test_case_3),
15305                 TEST_CASE_ST(ut_setup, ut_teardown,
15306                         test_kasumi_encryption_test_case_4),
15307                 TEST_CASE_ST(ut_setup, ut_teardown,
15308                         test_kasumi_encryption_test_case_5),
15309
15310                 /** KASUMI decrypt only (UEA1) */
15311                 TEST_CASE_ST(ut_setup, ut_teardown,
15312                         test_kasumi_decryption_test_case_1),
15313                 TEST_CASE_ST(ut_setup, ut_teardown,
15314                         test_kasumi_decryption_test_case_2),
15315                 TEST_CASE_ST(ut_setup, ut_teardown,
15316                         test_kasumi_decryption_test_case_3),
15317                 TEST_CASE_ST(ut_setup, ut_teardown,
15318                         test_kasumi_decryption_test_case_4),
15319                 TEST_CASE_ST(ut_setup, ut_teardown,
15320                         test_kasumi_decryption_test_case_5),
15321                 TEST_CASE_ST(ut_setup, ut_teardown,
15322                         test_kasumi_decryption_test_case_1_oop),
15323                 TEST_CASE_ST(ut_setup, ut_teardown,
15324                         test_kasumi_cipher_auth_test_case_1),
15325
15326                 /** KASUMI generate auth, then encrypt (F8) */
15327                 TEST_CASE_ST(ut_setup, ut_teardown,
15328                         test_kasumi_auth_cipher_test_case_1),
15329                 TEST_CASE_ST(ut_setup, ut_teardown,
15330                         test_kasumi_auth_cipher_test_case_2),
15331                 TEST_CASE_ST(ut_setup, ut_teardown,
15332                         test_kasumi_auth_cipher_test_case_2_oop),
15333                 TEST_CASE_ST(ut_setup, ut_teardown,
15334                         test_kasumi_auth_cipher_test_case_2_sgl),
15335                 TEST_CASE_ST(ut_setup, ut_teardown,
15336                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15337
15338                 /** KASUMI decrypt (F8), then verify auth */
15339                 TEST_CASE_ST(ut_setup, ut_teardown,
15340                         test_kasumi_auth_cipher_verify_test_case_1),
15341                 TEST_CASE_ST(ut_setup, ut_teardown,
15342                         test_kasumi_auth_cipher_verify_test_case_2),
15343                 TEST_CASE_ST(ut_setup, ut_teardown,
15344                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15345                 TEST_CASE_ST(ut_setup, ut_teardown,
15346                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15347                 TEST_CASE_ST(ut_setup, ut_teardown,
15348                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15349
15350                 TEST_CASES_END()
15351         }
15352 };
15353
15354 static struct unit_test_suite cryptodev_esn_testsuite  = {
15355         .suite_name = "ESN Test Suite",
15356         .setup = esn_testsuite_setup,
15357         .unit_test_cases = {
15358                 TEST_CASE_ST(ut_setup, ut_teardown,
15359                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15360                 TEST_CASE_ST(ut_setup, ut_teardown,
15361                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15362                 TEST_CASES_END()
15363         }
15364 };
15365
15366 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
15367         .suite_name = "Negative AES GCM Test Suite",
15368         .setup = negative_aes_gcm_testsuite_setup,
15369         .unit_test_cases = {
15370                 TEST_CASE_ST(ut_setup, ut_teardown,
15371                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
15372                 TEST_CASE_ST(ut_setup, ut_teardown,
15373                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15374                 TEST_CASE_ST(ut_setup, ut_teardown,
15375                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15376                 TEST_CASE_ST(ut_setup, ut_teardown,
15377                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15378                 TEST_CASE_ST(ut_setup, ut_teardown,
15379                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
15380                 TEST_CASE_ST(ut_setup, ut_teardown,
15381                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
15382                 TEST_CASE_ST(ut_setup, ut_teardown,
15383                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
15384                 TEST_CASE_ST(ut_setup, ut_teardown,
15385                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15386                 TEST_CASE_ST(ut_setup, ut_teardown,
15387                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15388                 TEST_CASE_ST(ut_setup, ut_teardown,
15389                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15390                 TEST_CASE_ST(ut_setup, ut_teardown,
15391                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
15392                 TEST_CASE_ST(ut_setup, ut_teardown,
15393                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
15394
15395                 TEST_CASES_END()
15396         }
15397 };
15398
15399 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
15400         .suite_name = "Negative AES GMAC Test Suite",
15401         .setup = negative_aes_gmac_testsuite_setup,
15402         .unit_test_cases = {
15403                 TEST_CASE_ST(ut_setup, ut_teardown,
15404                         authentication_verify_AES128_GMAC_fail_data_corrupt),
15405                 TEST_CASE_ST(ut_setup, ut_teardown,
15406                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
15407
15408                 TEST_CASES_END()
15409         }
15410 };
15411
15412 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
15413         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15414         .setup = mixed_cipher_hash_testsuite_setup,
15415         .unit_test_cases = {
15416                 /** AUTH AES CMAC + CIPHER AES CTR */
15417                 TEST_CASE_ST(ut_setup, ut_teardown,
15418                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15419                 TEST_CASE_ST(ut_setup, ut_teardown,
15420                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15421                 TEST_CASE_ST(ut_setup, ut_teardown,
15422                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15423                 TEST_CASE_ST(ut_setup, ut_teardown,
15424                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15425                 TEST_CASE_ST(ut_setup, ut_teardown,
15426                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15427                 TEST_CASE_ST(ut_setup, ut_teardown,
15428                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15429                 TEST_CASE_ST(ut_setup, ut_teardown,
15430                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15431                 TEST_CASE_ST(ut_setup, ut_teardown,
15432                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15433
15434                 /** AUTH ZUC + CIPHER SNOW3G */
15435                 TEST_CASE_ST(ut_setup, ut_teardown,
15436                         test_auth_zuc_cipher_snow_test_case_1),
15437                 TEST_CASE_ST(ut_setup, ut_teardown,
15438                         test_verify_auth_zuc_cipher_snow_test_case_1),
15439                 /** AUTH AES CMAC + CIPHER SNOW3G */
15440                 TEST_CASE_ST(ut_setup, ut_teardown,
15441                         test_auth_aes_cmac_cipher_snow_test_case_1),
15442                 TEST_CASE_ST(ut_setup, ut_teardown,
15443                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15444                 /** AUTH ZUC + CIPHER AES CTR */
15445                 TEST_CASE_ST(ut_setup, ut_teardown,
15446                         test_auth_zuc_cipher_aes_ctr_test_case_1),
15447                 TEST_CASE_ST(ut_setup, ut_teardown,
15448                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15449                 /** AUTH SNOW3G + CIPHER AES CTR */
15450                 TEST_CASE_ST(ut_setup, ut_teardown,
15451                         test_auth_snow_cipher_aes_ctr_test_case_1),
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15454                 /** AUTH SNOW3G + CIPHER ZUC */
15455                 TEST_CASE_ST(ut_setup, ut_teardown,
15456                         test_auth_snow_cipher_zuc_test_case_1),
15457                 TEST_CASE_ST(ut_setup, ut_teardown,
15458                         test_verify_auth_snow_cipher_zuc_test_case_1),
15459                 /** AUTH AES CMAC + CIPHER ZUC */
15460                 TEST_CASE_ST(ut_setup, ut_teardown,
15461                         test_auth_aes_cmac_cipher_zuc_test_case_1),
15462                 TEST_CASE_ST(ut_setup, ut_teardown,
15463                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15464
15465                 /** AUTH NULL + CIPHER SNOW3G */
15466                 TEST_CASE_ST(ut_setup, ut_teardown,
15467                         test_auth_null_cipher_snow_test_case_1),
15468                 TEST_CASE_ST(ut_setup, ut_teardown,
15469                         test_verify_auth_null_cipher_snow_test_case_1),
15470                 /** AUTH NULL + CIPHER ZUC */
15471                 TEST_CASE_ST(ut_setup, ut_teardown,
15472                         test_auth_null_cipher_zuc_test_case_1),
15473                 TEST_CASE_ST(ut_setup, ut_teardown,
15474                         test_verify_auth_null_cipher_zuc_test_case_1),
15475                 /** AUTH SNOW3G + CIPHER NULL */
15476                 TEST_CASE_ST(ut_setup, ut_teardown,
15477                         test_auth_snow_cipher_null_test_case_1),
15478                 TEST_CASE_ST(ut_setup, ut_teardown,
15479                         test_verify_auth_snow_cipher_null_test_case_1),
15480                 /** AUTH ZUC + CIPHER NULL */
15481                 TEST_CASE_ST(ut_setup, ut_teardown,
15482                         test_auth_zuc_cipher_null_test_case_1),
15483                 TEST_CASE_ST(ut_setup, ut_teardown,
15484                         test_verify_auth_zuc_cipher_null_test_case_1),
15485                 /** AUTH NULL + CIPHER AES CTR */
15486                 TEST_CASE_ST(ut_setup, ut_teardown,
15487                         test_auth_null_cipher_aes_ctr_test_case_1),
15488                 TEST_CASE_ST(ut_setup, ut_teardown,
15489                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15490                 /** AUTH AES CMAC + CIPHER NULL */
15491                 TEST_CASE_ST(ut_setup, ut_teardown,
15492                         test_auth_aes_cmac_cipher_null_test_case_1),
15493                 TEST_CASE_ST(ut_setup, ut_teardown,
15494                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15495                 TEST_CASES_END()
15496         }
15497 };
15498
15499 static int
15500 run_cryptodev_testsuite(const char *pmd_name)
15501 {
15502         uint8_t ret, j, i = 0, blk_start_idx = 0;
15503         const enum blockcipher_test_type blk_suites[] = {
15504                 BLKCIPHER_AES_CHAIN_TYPE,
15505                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15506                 BLKCIPHER_AES_DOCSIS_TYPE,
15507                 BLKCIPHER_3DES_CHAIN_TYPE,
15508                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15509                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15510                 BLKCIPHER_DES_DOCSIS_TYPE,
15511                 BLKCIPHER_AUTHONLY_TYPE};
15512         struct unit_test_suite *static_suites[] = {
15513                 &cryptodev_multi_session_testsuite,
15514                 &cryptodev_null_testsuite,
15515                 &cryptodev_aes_ccm_auth_testsuite,
15516                 &cryptodev_aes_gcm_auth_testsuite,
15517                 &cryptodev_aes_gmac_auth_testsuite,
15518                 &cryptodev_snow3g_testsuite,
15519                 &cryptodev_chacha20_poly1305_testsuite,
15520                 &cryptodev_zuc_testsuite,
15521                 &cryptodev_hmac_md5_auth_testsuite,
15522                 &cryptodev_kasumi_testsuite,
15523                 &cryptodev_esn_testsuite,
15524                 &cryptodev_negative_aes_gcm_testsuite,
15525                 &cryptodev_negative_aes_gmac_testsuite,
15526                 &cryptodev_mixed_cipher_hash_testsuite,
15527                 &cryptodev_negative_hmac_sha1_testsuite,
15528                 &cryptodev_gen_testsuite,
15529 #ifdef RTE_LIB_SECURITY
15530                 &ipsec_proto_testsuite,
15531                 &pdcp_proto_testsuite,
15532                 &docsis_proto_testsuite,
15533 #endif
15534                 &end_testsuite
15535         };
15536         static struct unit_test_suite ts = {
15537                 .suite_name = "Cryptodev Unit Test Suite",
15538                 .setup = testsuite_setup,
15539                 .teardown = testsuite_teardown,
15540                 .unit_test_cases = {TEST_CASES_END()}
15541         };
15542
15543         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15544
15545         if (gbl_driver_id == -1) {
15546                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15547                 return TEST_SKIPPED;
15548         }
15549
15550         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15551                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15552
15553         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15554         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15555         ret = unit_test_suite_runner(&ts);
15556
15557         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15558         free(ts.unit_test_suites);
15559         return ret;
15560 }
15561
15562 static int
15563 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15564 {
15565         struct rte_cryptodev_info dev_info;
15566         uint8_t i, nb_devs;
15567         int driver_id;
15568
15569         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15570         if (driver_id == -1) {
15571                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15572                 return TEST_SKIPPED;
15573         }
15574
15575         nb_devs = rte_cryptodev_count();
15576         if (nb_devs < 1) {
15577                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15578                 return TEST_SKIPPED;
15579         }
15580
15581         for (i = 0; i < nb_devs; i++) {
15582                 rte_cryptodev_info_get(i, &dev_info);
15583                 if (dev_info.driver_id == driver_id) {
15584                         if (!(dev_info.feature_flags & flag)) {
15585                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15586                                                 flag_name);
15587                                 return TEST_SKIPPED;
15588                         }
15589                         return 0; /* found */
15590                 }
15591         }
15592
15593         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15594         return TEST_SKIPPED;
15595 }
15596
15597 static int
15598 test_cryptodev_qat(void)
15599 {
15600         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15601 }
15602
15603 static int
15604 test_cryptodev_virtio(void)
15605 {
15606         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15607 }
15608
15609 static int
15610 test_cryptodev_aesni_mb(void)
15611 {
15612         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15613 }
15614
15615 static int
15616 test_cryptodev_cpu_aesni_mb(void)
15617 {
15618         int32_t rc;
15619         enum rte_security_session_action_type at = gbl_action_type;
15620         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15621         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15622         gbl_action_type = at;
15623         return rc;
15624 }
15625
15626 static int
15627 test_cryptodev_chacha_poly_mb(void)
15628 {
15629         int32_t rc;
15630         enum rte_security_session_action_type at = gbl_action_type;
15631         rc = run_cryptodev_testsuite(
15632                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15633         gbl_action_type = at;
15634         return rc;
15635 }
15636
15637 static int
15638 test_cryptodev_openssl(void)
15639 {
15640         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15641 }
15642
15643 static int
15644 test_cryptodev_aesni_gcm(void)
15645 {
15646         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15647 }
15648
15649 static int
15650 test_cryptodev_cpu_aesni_gcm(void)
15651 {
15652         int32_t rc;
15653         enum rte_security_session_action_type at = gbl_action_type;
15654         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15655         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15656         gbl_action_type = at;
15657         return rc;
15658 }
15659
15660 static int
15661 test_cryptodev_mlx5(void)
15662 {
15663         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15664 }
15665
15666 static int
15667 test_cryptodev_null(void)
15668 {
15669         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15670 }
15671
15672 static int
15673 test_cryptodev_sw_snow3g(void)
15674 {
15675         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15676 }
15677
15678 static int
15679 test_cryptodev_sw_kasumi(void)
15680 {
15681         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
15682 }
15683
15684 static int
15685 test_cryptodev_sw_zuc(void)
15686 {
15687         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
15688 }
15689
15690 static int
15691 test_cryptodev_armv8(void)
15692 {
15693         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
15694 }
15695
15696 static int
15697 test_cryptodev_mrvl(void)
15698 {
15699         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
15700 }
15701
15702 #ifdef RTE_CRYPTO_SCHEDULER
15703
15704 static int
15705 test_cryptodev_scheduler(void)
15706 {
15707         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
15708         const enum blockcipher_test_type blk_suites[] = {
15709                 BLKCIPHER_AES_CHAIN_TYPE,
15710                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15711                 BLKCIPHER_AUTHONLY_TYPE
15712         };
15713         static struct unit_test_suite scheduler_multicore = {
15714                 .suite_name = "Scheduler Multicore Unit Test Suite",
15715                 .setup = scheduler_multicore_testsuite_setup,
15716                 .teardown = scheduler_mode_testsuite_teardown,
15717                 .unit_test_cases = {TEST_CASES_END()}
15718         };
15719         static struct unit_test_suite scheduler_round_robin = {
15720                 .suite_name = "Scheduler Round Robin Unit Test Suite",
15721                 .setup = scheduler_roundrobin_testsuite_setup,
15722                 .teardown = scheduler_mode_testsuite_teardown,
15723                 .unit_test_cases = {TEST_CASES_END()}
15724         };
15725         static struct unit_test_suite scheduler_failover = {
15726                 .suite_name = "Scheduler Failover Unit Test Suite",
15727                 .setup = scheduler_failover_testsuite_setup,
15728                 .teardown = scheduler_mode_testsuite_teardown,
15729                 .unit_test_cases = {TEST_CASES_END()}
15730         };
15731         static struct unit_test_suite scheduler_pkt_size_distr = {
15732                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
15733                 .setup = scheduler_pkt_size_distr_testsuite_setup,
15734                 .teardown = scheduler_mode_testsuite_teardown,
15735                 .unit_test_cases = {TEST_CASES_END()}
15736         };
15737         struct unit_test_suite *sched_mode_suites[] = {
15738                 &scheduler_multicore,
15739                 &scheduler_round_robin,
15740                 &scheduler_failover,
15741                 &scheduler_pkt_size_distr
15742         };
15743         static struct unit_test_suite scheduler_config = {
15744                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
15745                 .unit_test_cases = {
15746                         TEST_CASE(test_scheduler_attach_worker_op),
15747                         TEST_CASE(test_scheduler_mode_multicore_op),
15748                         TEST_CASE(test_scheduler_mode_roundrobin_op),
15749                         TEST_CASE(test_scheduler_mode_failover_op),
15750                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
15751                         TEST_CASE(test_scheduler_detach_worker_op),
15752
15753                         TEST_CASES_END() /**< NULL terminate array */
15754                 }
15755         };
15756         struct unit_test_suite *static_suites[] = {
15757                 &scheduler_config,
15758                 &end_testsuite
15759         };
15760         static struct unit_test_suite ts = {
15761                 .suite_name = "Scheduler Unit Test Suite",
15762                 .setup = scheduler_testsuite_setup,
15763                 .teardown = testsuite_teardown,
15764                 .unit_test_cases = {TEST_CASES_END()}
15765         };
15766
15767         gbl_driver_id = rte_cryptodev_driver_id_get(
15768                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
15769
15770         if (gbl_driver_id == -1) {
15771                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
15772                 return TEST_SKIPPED;
15773         }
15774
15775         if (rte_cryptodev_driver_id_get(
15776                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
15777                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
15778                 return TEST_SKIPPED;
15779         }
15780
15781         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15782                 uint8_t blk_i = 0;
15783                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
15784                                 (struct unit_test_suite *) *
15785                                 (RTE_DIM(blk_suites) + 1));
15786                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
15787                                 blk_suites, RTE_DIM(blk_suites));
15788                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
15789         }
15790
15791         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15792                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
15793         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
15794                         RTE_DIM(sched_mode_suites));
15795         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15796         ret = unit_test_suite_runner(&ts);
15797
15798         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
15799                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
15800                                 (*sched_mode_suites[sched_i]),
15801                                 RTE_DIM(blk_suites));
15802                 free(sched_mode_suites[sched_i]->unit_test_suites);
15803         }
15804         free(ts.unit_test_suites);
15805         return ret;
15806 }
15807
15808 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
15809
15810 #endif
15811
15812 static int
15813 test_cryptodev_dpaa2_sec(void)
15814 {
15815         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
15816 }
15817
15818 static int
15819 test_cryptodev_dpaa_sec(void)
15820 {
15821         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
15822 }
15823
15824 static int
15825 test_cryptodev_ccp(void)
15826 {
15827         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
15828 }
15829
15830 static int
15831 test_cryptodev_octeontx(void)
15832 {
15833         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
15834 }
15835
15836 static int
15837 test_cryptodev_caam_jr(void)
15838 {
15839         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
15840 }
15841
15842 static int
15843 test_cryptodev_nitrox(void)
15844 {
15845         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
15846 }
15847
15848 static int
15849 test_cryptodev_bcmfs(void)
15850 {
15851         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
15852 }
15853
15854 static int
15855 test_cryptodev_qat_raw_api(void)
15856 {
15857         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
15858         int ret;
15859
15860         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15861                         "RAW API");
15862         if (ret)
15863                 return ret;
15864
15865         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15866         ret = run_cryptodev_testsuite(pmd_name);
15867         global_api_test_type = CRYPTODEV_API_TEST;
15868
15869         return ret;
15870 }
15871
15872 static int
15873 test_cryptodev_cn9k(void)
15874 {
15875         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
15876 }
15877
15878 static int
15879 test_cryptodev_cn10k(void)
15880 {
15881         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
15882 }
15883
15884 static int
15885 test_cryptodev_dpaa2_sec_raw_api(void)
15886 {
15887         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15888         int ret;
15889
15890         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15891                         "RAW API");
15892         if (ret)
15893                 return ret;
15894
15895         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15896         ret = run_cryptodev_testsuite(pmd_name);
15897         global_api_test_type = CRYPTODEV_API_TEST;
15898
15899         return ret;
15900 }
15901
15902 static int
15903 test_cryptodev_dpaa_sec_raw_api(void)
15904 {
15905         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
15906         int ret;
15907
15908         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
15909                         "RAW API");
15910         if (ret)
15911                 return ret;
15912
15913         global_api_test_type = CRYPTODEV_RAW_API_TEST;
15914         ret = run_cryptodev_testsuite(pmd_name);
15915         global_api_test_type = CRYPTODEV_API_TEST;
15916
15917         return ret;
15918 }
15919
15920 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
15921                 test_cryptodev_dpaa2_sec_raw_api);
15922 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
15923                 test_cryptodev_dpaa_sec_raw_api);
15924 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
15925                 test_cryptodev_qat_raw_api);
15926 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
15927 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
15928 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
15929         test_cryptodev_cpu_aesni_mb);
15930 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
15931         test_cryptodev_chacha_poly_mb);
15932 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
15933 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
15934 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
15935         test_cryptodev_cpu_aesni_gcm);
15936 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
15937 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
15938 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
15939 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
15940 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
15941 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
15942 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
15943 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
15944 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
15945 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
15946 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
15947 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
15948 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
15949 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
15950 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
15951 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
15952 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);