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 #ifndef RTE_EXEC_ENV_WINDOWS
   7
   8 #include <time.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_hexdump.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_malloc.h>
  14 #include <rte_memcpy.h>
  15 #include <rte_pause.h>
  16 #include <rte_bus_vdev.h>
  17 #include <rte_ether.h>
  18
  19 #include <rte_crypto.h>
  20 #include <rte_cryptodev.h>
  21 #include <rte_ip.h>
  22 #include <rte_string_fns.h>
  23 #include <rte_tcp.h>
  24 #include <rte_udp.h>
  25
  26 #ifdef RTE_CRYPTO_SCHEDULER
  27 #include <rte_cryptodev_scheduler.h>
  28 #include <rte_cryptodev_scheduler_operations.h>
  29 #endif
  30
  31 #include <rte_lcore.h>
  32
  33 #include "test.h"
  34 #include "test_cryptodev.h"
  35
  36 #include "test_cryptodev_blockcipher.h"
  37 #include "test_cryptodev_aes_test_vectors.h"
  38 #include "test_cryptodev_des_test_vectors.h"
  39 #include "test_cryptodev_hash_test_vectors.h"
  40 #include "test_cryptodev_kasumi_test_vectors.h"
  41 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  42 #include "test_cryptodev_snow3g_test_vectors.h"
  43 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  44 #include "test_cryptodev_zuc_test_vectors.h"
  45 #include "test_cryptodev_aead_test_vectors.h"
  46 #include "test_cryptodev_hmac_test_vectors.h"
  47 #include "test_cryptodev_mixed_test_vectors.h"
  48 #ifdef RTE_LIB_SECURITY
  49 #include "test_cryptodev_security_ipsec.h"
  50 #include "test_cryptodev_security_ipsec_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_vectors.h"
  52 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  53 #include "test_cryptodev_security_pdcp_test_func.h"
  54 #include "test_cryptodev_security_docsis_test_vectors.h"
  55
  56 #define SDAP_DISABLED   0
  57 #define SDAP_ENABLED    1
  58 #endif
  59
  60 #define VDEV_ARGS_SIZE 100
  61 #define MAX_NB_SESSIONS 4
  62
  63 #define MAX_DRV_SERVICE_CTX_SIZE 256
  64
  65 #define MAX_RAW_DEQUEUE_COUNT   65535
  66
  67 #define IN_PLACE 0
  68 #define OUT_OF_PLACE 1
  69
  70 static int gbl_driver_id;
  71
  72 static enum rte_security_session_action_type gbl_action_type =
  73         RTE_SECURITY_ACTION_TYPE_NONE;
  74
  75 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  76
  77 struct crypto_unittest_params {
  78         struct rte_crypto_sym_xform cipher_xform;
  79         struct rte_crypto_sym_xform auth_xform;
  80         struct rte_crypto_sym_xform aead_xform;
  81 #ifdef RTE_LIB_SECURITY
  82         struct rte_security_docsis_xform docsis_xform;
  83 #endif
  84
  85         union {
  86                 struct rte_cryptodev_sym_session *sess;
  87 #ifdef RTE_LIB_SECURITY
  88                 struct rte_security_session *sec_session;
  89 #endif
  90         };
  91 #ifdef RTE_LIB_SECURITY
  92         enum rte_security_session_action_type type;
  93 #endif
  94         struct rte_crypto_op *op;
  95
  96         struct rte_mbuf *obuf, *ibuf;
  97
  98         uint8_t *digest;
  99 };
 100
 101 #define ALIGN_POW2_ROUNDUP(num, align) \
 102         (((num) + (align) - 1) & ~((align) - 1))
 103
 104 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 105         for (j = 0; j < num_child_ts; index++, j++)                     \
 106                 parent_ts.unit_test_suites[index] = child_ts[j]
 107
 108 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 109         for (j = 0; j < num_blk_types; index++, j++)                            \
 110                 parent_ts.unit_test_suites[index] =                             \
 111                                 build_blockcipher_test_suite(blk_types[j])
 112
 113 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 114         for (j = index; j < index + num_blk_types; j++)                         \
 115                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 116
 117 /*
 118  * Forward declarations.
 119  */
 120 static int
 121 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 122                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 123                 uint8_t *hmac_key);
 124
 125 static int
 126 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 127                 struct crypto_unittest_params *ut_params,
 128                 struct crypto_testsuite_params *ts_param,
 129                 const uint8_t *cipher,
 130                 const uint8_t *digest,
 131                 const uint8_t *iv);
 132
 133 static int
 134 security_proto_supported(enum rte_security_session_action_type action,
 135         enum rte_security_session_protocol proto);
 136
 137 static int
 138 dev_configure_and_start(uint64_t ff_disable);
 139
 140 static struct rte_mbuf *
 141 setup_test_string(struct rte_mempool *mpool,
 142                 const char *string, size_t len, uint8_t blocksize)
 143 {
 144         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 145         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 146
 147         if (m) {
 148                 char *dst;
 149
 150                 memset(m->buf_addr, 0, m->buf_len);
 151                 dst = rte_pktmbuf_append(m, t_len);
 152                 if (!dst) {
 153                         rte_pktmbuf_free(m);
 154                         return NULL;
 155                 }
 156                 if (string != NULL)
 157                         rte_memcpy(dst, string, t_len);
 158                 else
 159                         memset(dst, 0, t_len);
 160         }
 161
 162         return m;
 163 }
 164
 165 /* Get number of bytes in X bits (rounding up) */
 166 static uint32_t
 167 ceil_byte_length(uint32_t num_bits)
 168 {
 169         if (num_bits % 8)
 170                 return ((num_bits >> 3) + 1);
 171         else
 172                 return (num_bits >> 3);
 173 }
 174
 175 static void
 176 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 177                 uint8_t is_op_success)
 178 {
 179         struct rte_crypto_op *op = user_data;
 180         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 181                         RTE_CRYPTO_OP_STATUS_ERROR;
 182 }
 183
 184 static struct crypto_testsuite_params testsuite_params = { NULL };
 185 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 186 static struct crypto_unittest_params unittest_params;
 187
 188 void
 189 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 190                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 191                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 192 {
 193         struct rte_crypto_sym_op *sop = op->sym;
 194         struct rte_crypto_op *ret_op = NULL;
 195         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 196         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 197         union rte_crypto_sym_ofs ofs;
 198         struct rte_crypto_sym_vec vec;
 199         struct rte_crypto_sgl sgl, dest_sgl;
 200         uint32_t max_len;
 201         union rte_cryptodev_session_ctx sess;
 202         uint64_t auth_end_iova;
 203         uint32_t count = 0;
 204         struct rte_crypto_raw_dp_ctx *ctx;
 205         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 206                         auth_len = 0;
 207         int32_t n;
 208         uint32_t n_success;
 209         int ctx_service_size;
 210         int32_t status = 0;
 211         int enqueue_status, dequeue_status;
 212         struct crypto_unittest_params *ut_params = &unittest_params;
 213         int is_sgl = sop->m_src->nb_segs > 1;
 214         int is_oop = 0;
 215
 216         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 217         if (ctx_service_size < 0) {
 218                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 219                 return;
 220         }
 221
 222         ctx = malloc(ctx_service_size);
 223         if (!ctx) {
 224                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 225                 return;
 226         }
 227
 228         /* Both are enums, setting crypto_sess will suit any session type */
 229         sess.crypto_sess = op->sym->session;
 230
 231         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 232                         op->sess_type, sess, 0) < 0) {
 233                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 234                 goto exit;
 235         }
 236
 237         cipher_iv.iova = 0;
 238         cipher_iv.va = NULL;
 239         aad_auth_iv.iova = 0;
 240         aad_auth_iv.va = NULL;
 241         digest.iova = 0;
 242         digest.va = NULL;
 243         sgl.vec = data_vec;
 244         vec.num = 1;
 245         vec.src_sgl = &sgl;
 246         vec.iv = &cipher_iv;
 247         vec.digest = &digest;
 248         vec.aad = &aad_auth_iv;
 249         vec.status = &status;
 250
 251         ofs.raw = 0;
 252
 253         if ((sop->m_dst != NULL) && (sop->m_dst != sop->m_src))
 254                 is_oop = 1;
 255
 256         if (is_cipher && is_auth) {
 257                 cipher_offset = sop->cipher.data.offset;
 258                 cipher_len = sop->cipher.data.length;
 259                 auth_offset = sop->auth.data.offset;
 260                 auth_len = sop->auth.data.length;
 261                 max_len = RTE_MAX(cipher_offset + cipher_len,
 262                                 auth_offset + auth_len);
 263                 if (len_in_bits) {
 264                         max_len = max_len >> 3;
 265                         cipher_offset = cipher_offset >> 3;
 266                         auth_offset = auth_offset >> 3;
 267                         cipher_len = cipher_len >> 3;
 268                         auth_len = auth_len >> 3;
 269                 }
 270                 ofs.ofs.cipher.head = cipher_offset;
 271                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 272                 ofs.ofs.auth.head = auth_offset;
 273                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 274                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 275                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 276                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 277                                 op, void *, IV_OFFSET + cipher_iv_len);
 278                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 279                                 cipher_iv_len);
 280                 digest.va = (void *)sop->auth.digest.data;
 281                 digest.iova = sop->auth.digest.phys_addr;
 282
 283                 if (is_sgl) {
 284                         uint32_t remaining_off = auth_offset + auth_len;
 285                         struct rte_mbuf *sgl_buf = sop->m_src;
 286                         if (is_oop)
 287                                 sgl_buf = sop->m_dst;
 288
 289                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 290                                         && sgl_buf->next != NULL) {
 291                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 292                                 sgl_buf = sgl_buf->next;
 293                         }
 294
 295                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 296                                 sgl_buf, remaining_off);
 297                 } else {
 298                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 299                                                          auth_offset + auth_len;
 300                 }
 301                 /* Then check if digest-encrypted conditions are met */
 302                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 303                                 (digest.iova == auth_end_iova) && is_sgl)
 304                         max_len = RTE_MAX(max_len,
 305                                 auth_offset + auth_len +
 306                                 ut_params->auth_xform.auth.digest_length);
 307
 308         } else if (is_cipher) {
 309                 cipher_offset = sop->cipher.data.offset;
 310                 cipher_len = sop->cipher.data.length;
 311                 max_len = cipher_len + cipher_offset;
 312                 if (len_in_bits) {
 313                         max_len = max_len >> 3;
 314                         cipher_offset = cipher_offset >> 3;
 315                         cipher_len = cipher_len >> 3;
 316                 }
 317                 ofs.ofs.cipher.head = cipher_offset;
 318                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 319                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 320                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 321
 322         } else if (is_auth) {
 323                 auth_offset = sop->auth.data.offset;
 324                 auth_len = sop->auth.data.length;
 325                 max_len = auth_len + auth_offset;
 326                 if (len_in_bits) {
 327                         max_len = max_len >> 3;
 328                         auth_offset = auth_offset >> 3;
 329                         auth_len = auth_len >> 3;
 330                 }
 331                 ofs.ofs.auth.head = auth_offset;
 332                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 333                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 334                                 op, void *, IV_OFFSET + cipher_iv_len);
 335                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 336                                 cipher_iv_len);
 337                 digest.va = (void *)sop->auth.digest.data;
 338                 digest.iova = sop->auth.digest.phys_addr;
 339
 340         } else { /* aead */
 341                 cipher_offset = sop->aead.data.offset;
 342                 cipher_len = sop->aead.data.length;
 343                 max_len = cipher_len + cipher_offset;
 344                 if (len_in_bits) {
 345                         max_len = max_len >> 3;
 346                         cipher_offset = cipher_offset >> 3;
 347                         cipher_len = cipher_len >> 3;
 348                 }
 349                 ofs.ofs.cipher.head = cipher_offset;
 350                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 351                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 352                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 353                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 354                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 355                 digest.va = (void *)sop->aead.digest.data;
 356                 digest.iova = sop->aead.digest.phys_addr;
 357         }
 358
 359         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 360                         data_vec, RTE_DIM(data_vec));
 361         if (n < 0 || n > sop->m_src->nb_segs) {
 362                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 363                 goto exit;
 364         }
 365
 366         sgl.num = n;
 367         /* Out of place */
 368         if (is_oop) {
 369                 dest_sgl.vec = dest_data_vec;
 370                 vec.dest_sgl = &dest_sgl;
 371                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 372                                 dest_data_vec, RTE_DIM(dest_data_vec));
 373                 if (n < 0 || n > sop->m_dst->nb_segs) {
 374                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                         goto exit;
 376                 }
 377                 dest_sgl.num = n;
 378         } else
 379                 vec.dest_sgl = NULL;
 380
 381         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 382                         &enqueue_status) < 1) {
 383                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 384                 goto exit;
 385         }
 386
 387         if (enqueue_status == 0) {
 388                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 389                 if (status < 0) {
 390                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 391                         goto exit;
 392                 }
 393         } else if (enqueue_status < 0) {
 394                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 395                 goto exit;
 396         }
 397
 398         n = n_success = 0;
 399         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 400                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 401                         NULL, 1, post_process_raw_dp_op,
 402                                 (void **)&ret_op, 0, &n_success,
 403                                 &dequeue_status);
 404                 if (dequeue_status < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408                 if (n == 0)
 409                         rte_pause();
 410         }
 411
 412         if (n == 1 && dequeue_status == 0) {
 413                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 414                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 415                         goto exit;
 416                 }
 417         }
 418
 419         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 420                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 421                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 422                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 423
 424 exit:
 425         free(ctx);
 426 }
 427
 428 static void
 429 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 430 {
 431         int32_t n, st;
 432         struct rte_crypto_sym_op *sop;
 433         union rte_crypto_sym_ofs ofs;
 434         struct rte_crypto_sgl sgl;
 435         struct rte_crypto_sym_vec symvec;
 436         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 437         struct rte_crypto_vec vec[UINT8_MAX];
 438
 439         sop = op->sym;
 440
 441         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 442                 sop->aead.data.length, vec, RTE_DIM(vec));
 443
 444         if (n < 0 || n != sop->m_src->nb_segs) {
 445                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 446                 return;
 447         }
 448
 449         sgl.vec = vec;
 450         sgl.num = n;
 451         symvec.src_sgl = &sgl;
 452         symvec.iv = &iv_ptr;
 453         symvec.digest = &digest_ptr;
 454         symvec.aad = &aad_ptr;
 455         symvec.status = &st;
 456         symvec.num = 1;
 457
 458         /* for CPU crypto the IOVA address is not required */
 459         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 460         digest_ptr.va = (void *)sop->aead.digest.data;
 461         aad_ptr.va = (void *)sop->aead.aad.data;
 462
 463         ofs.raw = 0;
 464
 465         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 466                 &symvec);
 467
 468         if (n != 1)
 469                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 470         else
 471                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 472 }
 473
 474 static void
 475 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 476 {
 477         int32_t n, st;
 478         struct rte_crypto_sym_op *sop;
 479         union rte_crypto_sym_ofs ofs;
 480         struct rte_crypto_sgl sgl;
 481         struct rte_crypto_sym_vec symvec;
 482         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 483         struct rte_crypto_vec vec[UINT8_MAX];
 484
 485         sop = op->sym;
 486
 487         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 488                 sop->auth.data.length, vec, RTE_DIM(vec));
 489
 490         if (n < 0 || n != sop->m_src->nb_segs) {
 491                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 492                 return;
 493         }
 494
 495         sgl.vec = vec;
 496         sgl.num = n;
 497         symvec.src_sgl = &sgl;
 498         symvec.iv = &iv_ptr;
 499         symvec.digest = &digest_ptr;
 500         symvec.status = &st;
 501         symvec.num = 1;
 502
 503         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 504         digest_ptr.va = (void *)sop->auth.digest.data;
 505
 506         ofs.raw = 0;
 507         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 508         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 509                 (sop->cipher.data.offset + sop->cipher.data.length);
 510
 511         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 512                 &symvec);
 513
 514         if (n != 1)
 515                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 516         else
 517                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 518 }
 519
 520 static struct rte_crypto_op *
 521 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 522 {
 523
 524         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 525
 526         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 527                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 528                 return NULL;
 529         }
 530
 531         op = NULL;
 532
 533         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 534                 rte_pause();
 535
 536         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 537                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 538                 return NULL;
 539         }
 540
 541         return op;
 542 }
 543
 544 static int
 545 testsuite_setup(void)
 546 {
 547         struct crypto_testsuite_params *ts_params = &testsuite_params;
 548         struct rte_cryptodev_info info;
 549         uint32_t i = 0, nb_devs, dev_id;
 550         uint16_t qp_id;
 551
 552         memset(ts_params, 0, sizeof(*ts_params));
 553
 554         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 555         if (ts_params->mbuf_pool == NULL) {
 556                 /* Not already created so create */
 557                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 558                                 "CRYPTO_MBUFPOOL",
 559                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 560                                 rte_socket_id());
 561                 if (ts_params->mbuf_pool == NULL) {
 562                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 563                         return TEST_FAILED;
 564                 }
 565         }
 566
 567         ts_params->large_mbuf_pool = rte_mempool_lookup(
 568                         "CRYPTO_LARGE_MBUFPOOL");
 569         if (ts_params->large_mbuf_pool == NULL) {
 570                 /* Not already created so create */
 571                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 572                                 "CRYPTO_LARGE_MBUFPOOL",
 573                                 1, 0, 0, UINT16_MAX,
 574                                 rte_socket_id());
 575                 if (ts_params->large_mbuf_pool == NULL) {
 576                         RTE_LOG(ERR, USER1,
 577                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 578                         return TEST_FAILED;
 579                 }
 580         }
 581
 582         ts_params->op_mpool = rte_crypto_op_pool_create(
 583                         "MBUF_CRYPTO_SYM_OP_POOL",
 584                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 585                         NUM_MBUFS, MBUF_CACHE_SIZE,
 586                         DEFAULT_NUM_XFORMS *
 587                         sizeof(struct rte_crypto_sym_xform) +
 588                         MAXIMUM_IV_LENGTH,
 589                         rte_socket_id());
 590         if (ts_params->op_mpool == NULL) {
 591                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 592                 return TEST_FAILED;
 593         }
 594
 595         nb_devs = rte_cryptodev_count();
 596         if (nb_devs < 1) {
 597                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 598                 return TEST_SKIPPED;
 599         }
 600
 601         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 602                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 603                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 604                 return TEST_SKIPPED;
 605         }
 606
 607         /* Create list of valid crypto devs */
 608         for (i = 0; i < nb_devs; i++) {
 609                 rte_cryptodev_info_get(i, &info);
 610                 if (info.driver_id == gbl_driver_id)
 611                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 612         }
 613
 614         if (ts_params->valid_dev_count < 1)
 615                 return TEST_FAILED;
 616
 617         /* Set up all the qps on the first of the valid devices found */
 618
 619         dev_id = ts_params->valid_devs[0];
 620
 621         rte_cryptodev_info_get(dev_id, &info);
 622
 623         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 624         ts_params->conf.socket_id = SOCKET_ID_ANY;
 625         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 626
 627         unsigned int session_size =
 628                 rte_cryptodev_sym_get_private_session_size(dev_id);
 629
 630 #ifdef RTE_LIB_SECURITY
 631         unsigned int security_session_size = rte_security_session_get_size(
 632                         rte_cryptodev_get_sec_ctx(dev_id));
 633
 634         if (session_size < security_session_size)
 635                 session_size = security_session_size;
 636 #endif
 637         /*
 638          * Create mempool with maximum number of sessions.
 639          */
 640         if (info.sym.max_nb_sessions != 0 &&
 641                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 642                 RTE_LOG(ERR, USER1, "Device does not support "
 643                                 "at least %u sessions\n",
 644                                 MAX_NB_SESSIONS);
 645                 return TEST_FAILED;
 646         }
 647
 648         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 649                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 650                         SOCKET_ID_ANY);
 651         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 652                         "session mempool allocation failed");
 653
 654         ts_params->session_priv_mpool = rte_mempool_create(
 655                         "test_sess_mp_priv",
 656                         MAX_NB_SESSIONS,
 657                         session_size,
 658                         0, 0, NULL, NULL, NULL,
 659                         NULL, SOCKET_ID_ANY,
 660                         0);
 661         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 662                         "session mempool allocation failed");
 663
 664
 665
 666         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 667                         &ts_params->conf),
 668                         "Failed to configure cryptodev %u with %u qps",
 669                         dev_id, ts_params->conf.nb_queue_pairs);
 670
 671         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 672         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 673         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 674
 675         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 676                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 677                         dev_id, qp_id, &ts_params->qp_conf,
 678                         rte_cryptodev_socket_id(dev_id)),
 679                         "Failed to setup queue pair %u on cryptodev %u",
 680                         qp_id, dev_id);
 681         }
 682
 683         return TEST_SUCCESS;
 684 }
 685
 686 static void
 687 testsuite_teardown(void)
 688 {
 689         struct crypto_testsuite_params *ts_params = &testsuite_params;
 690         int res;
 691
 692         if (ts_params->mbuf_pool != NULL) {
 693                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 694                 rte_mempool_avail_count(ts_params->mbuf_pool));
 695         }
 696
 697         if (ts_params->op_mpool != NULL) {
 698                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 699                 rte_mempool_avail_count(ts_params->op_mpool));
 700         }
 701
 702         /* Free session mempools */
 703         if (ts_params->session_priv_mpool != NULL) {
 704                 rte_mempool_free(ts_params->session_priv_mpool);
 705                 ts_params->session_priv_mpool = NULL;
 706         }
 707
 708         if (ts_params->session_mpool != NULL) {
 709                 rte_mempool_free(ts_params->session_mpool);
 710                 ts_params->session_mpool = NULL;
 711         }
 712
 713         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 714         if (res)
 715                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 716 }
 717
 718 static int
 719 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 720                 const int *algs, uint16_t num_algs)
 721 {
 722         uint8_t dev_id = testsuite_params.valid_devs[0];
 723         bool some_alg_supported = FALSE;
 724         uint16_t i;
 725
 726         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 727                 struct rte_cryptodev_sym_capability_idx alg = {
 728                         type, {algs[i]}
 729                 };
 730                 if (rte_cryptodev_sym_capability_get(dev_id,
 731                                 &alg) != NULL)
 732                         some_alg_supported = TRUE;
 733         }
 734         if (!some_alg_supported)
 735                 return TEST_SKIPPED;
 736
 737         return 0;
 738 }
 739
 740 int
 741 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 742                 uint16_t num_ciphers)
 743 {
 744         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 745                         (const int *) ciphers, num_ciphers);
 746 }
 747
 748 int
 749 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 750                 uint16_t num_auths)
 751 {
 752         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 753                         (const int *) auths, num_auths);
 754 }
 755
 756 int
 757 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 758                 uint16_t num_aeads)
 759 {
 760         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 761                         (const int *) aeads, num_aeads);
 762 }
 763
 764 static int
 765 null_testsuite_setup(void)
 766 {
 767         struct crypto_testsuite_params *ts_params = &testsuite_params;
 768         uint8_t dev_id = ts_params->valid_devs[0];
 769         struct rte_cryptodev_info dev_info;
 770         const enum rte_crypto_cipher_algorithm ciphers[] = {
 771                 RTE_CRYPTO_CIPHER_NULL
 772         };
 773         const enum rte_crypto_auth_algorithm auths[] = {
 774                 RTE_CRYPTO_AUTH_NULL
 775         };
 776
 777         rte_cryptodev_info_get(dev_id, &dev_info);
 778
 779         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 780                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 781                                 "testsuite not met\n");
 782                 return TEST_SKIPPED;
 783         }
 784
 785         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 786                         && check_auth_capabilities_supported(auths,
 787                         RTE_DIM(auths)) != 0) {
 788                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 789                                 "testsuite not met\n");
 790                 return TEST_SKIPPED;
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int
 797 crypto_gen_testsuite_setup(void)
 798 {
 799         struct crypto_testsuite_params *ts_params = &testsuite_params;
 800         uint8_t dev_id = ts_params->valid_devs[0];
 801         struct rte_cryptodev_info dev_info;
 802
 803         rte_cryptodev_info_get(dev_id, &dev_info);
 804
 805         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 806                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 807                                 "testsuite not met\n");
 808                 return TEST_SKIPPED;
 809         }
 810
 811         return 0;
 812 }
 813
 814 #ifdef RTE_LIB_SECURITY
 815 static int
 816 ipsec_proto_testsuite_setup(void)
 817 {
 818         struct crypto_testsuite_params *ts_params = &testsuite_params;
 819         struct crypto_unittest_params *ut_params = &unittest_params;
 820         struct rte_cryptodev_info dev_info;
 821         int ret = 0;
 822
 823         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 824
 825         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 826                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 827                                 "testsuite not met\n");
 828                 return TEST_SKIPPED;
 829         }
 830
 831         /* Reconfigure to enable security */
 832         ret = dev_configure_and_start(0);
 833         if (ret != TEST_SUCCESS)
 834                 return ret;
 835
 836         /* Set action type */
 837         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 838
 839         if (security_proto_supported(
 840                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 841                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 842                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 843                                 "test not met\n");
 844                 ret = TEST_SKIPPED;
 845         }
 846
 847         test_ipsec_alg_list_populate();
 848         test_ipsec_ah_alg_list_populate();
 849
 850         /*
 851          * Stop the device. Device would be started again by individual test
 852          * case setup routine.
 853          */
 854         rte_cryptodev_stop(ts_params->valid_devs[0]);
 855
 856         return ret;
 857 }
 858
 859 static int
 860 pdcp_proto_testsuite_setup(void)
 861 {
 862         struct crypto_testsuite_params *ts_params = &testsuite_params;
 863         uint8_t dev_id = ts_params->valid_devs[0];
 864         struct rte_cryptodev_info dev_info;
 865         const enum rte_crypto_cipher_algorithm ciphers[] = {
 866                 RTE_CRYPTO_CIPHER_NULL,
 867                 RTE_CRYPTO_CIPHER_AES_CTR,
 868                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 869                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 870         };
 871         const enum rte_crypto_auth_algorithm auths[] = {
 872                 RTE_CRYPTO_AUTH_NULL,
 873                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 874                 RTE_CRYPTO_AUTH_AES_CMAC,
 875                 RTE_CRYPTO_AUTH_ZUC_EIA3
 876         };
 877
 878         rte_cryptodev_info_get(dev_id, &dev_info);
 879
 880         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 881                         !(dev_info.feature_flags &
 882                         RTE_CRYPTODEV_FF_SECURITY)) {
 883                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 884                                 "testsuite not met\n");
 885                 return TEST_SKIPPED;
 886         }
 887
 888         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 889                         && check_auth_capabilities_supported(auths,
 890                         RTE_DIM(auths)) != 0) {
 891                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 892                                 "testsuite not met\n");
 893                 return TEST_SKIPPED;
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int
 900 docsis_proto_testsuite_setup(void)
 901 {
 902         struct crypto_testsuite_params *ts_params = &testsuite_params;
 903         uint8_t dev_id = ts_params->valid_devs[0];
 904         struct rte_cryptodev_info dev_info;
 905         const enum rte_crypto_cipher_algorithm ciphers[] = {
 906                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 907         };
 908
 909         rte_cryptodev_info_get(dev_id, &dev_info);
 910
 911         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 912                         !(dev_info.feature_flags &
 913                         RTE_CRYPTODEV_FF_SECURITY)) {
 914                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 915                                 "Proto testsuite not met\n");
 916                 return TEST_SKIPPED;
 917         }
 918
 919         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 920                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 921                                 "testsuite not met\n");
 922                 return TEST_SKIPPED;
 923         }
 924
 925         return 0;
 926 }
 927 #endif
 928
 929 static int
 930 aes_ccm_auth_testsuite_setup(void)
 931 {
 932         struct crypto_testsuite_params *ts_params = &testsuite_params;
 933         uint8_t dev_id = ts_params->valid_devs[0];
 934         struct rte_cryptodev_info dev_info;
 935         const enum rte_crypto_aead_algorithm aeads[] = {
 936                 RTE_CRYPTO_AEAD_AES_CCM
 937         };
 938
 939         rte_cryptodev_info_get(dev_id, &dev_info);
 940
 941         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 942                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 943                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 944                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 945                                 "testsuite not met\n");
 946                 return TEST_SKIPPED;
 947         }
 948
 949         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 950                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 951                                 "testsuite not met\n");
 952                 return TEST_SKIPPED;
 953         }
 954
 955         return 0;
 956 }
 957
 958 static int
 959 aes_gcm_auth_testsuite_setup(void)
 960 {
 961         struct crypto_testsuite_params *ts_params = &testsuite_params;
 962         uint8_t dev_id = ts_params->valid_devs[0];
 963         struct rte_cryptodev_info dev_info;
 964         const enum rte_crypto_aead_algorithm aeads[] = {
 965                 RTE_CRYPTO_AEAD_AES_GCM
 966         };
 967
 968         rte_cryptodev_info_get(dev_id, &dev_info);
 969
 970         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 971                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 972                                 "testsuite not met\n");
 973                 return TEST_SKIPPED;
 974         }
 975
 976         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 977                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 978                                 "testsuite not met\n");
 979                 return TEST_SKIPPED;
 980         }
 981
 982         return 0;
 983 }
 984
 985 static int
 986 aes_gmac_auth_testsuite_setup(void)
 987 {
 988         struct crypto_testsuite_params *ts_params = &testsuite_params;
 989         uint8_t dev_id = ts_params->valid_devs[0];
 990         struct rte_cryptodev_info dev_info;
 991         const enum rte_crypto_auth_algorithm auths[] = {
 992                 RTE_CRYPTO_AUTH_AES_GMAC
 993         };
 994
 995         rte_cryptodev_info_get(dev_id, &dev_info);
 996
 997         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 998                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 999                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1000                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
1001                                 "testsuite not met\n");
1002                 return TEST_SKIPPED;
1003         }
1004
1005         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1006                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
1007                                 "testsuite not met\n");
1008                 return TEST_SKIPPED;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int
1015 chacha20_poly1305_testsuite_setup(void)
1016 {
1017         struct crypto_testsuite_params *ts_params = &testsuite_params;
1018         uint8_t dev_id = ts_params->valid_devs[0];
1019         struct rte_cryptodev_info dev_info;
1020         const enum rte_crypto_aead_algorithm aeads[] = {
1021                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1022         };
1023
1024         rte_cryptodev_info_get(dev_id, &dev_info);
1025
1026         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1027                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1028                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1029                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1030                                 "Chacha20-Poly1305 testsuite not met\n");
1031                 return TEST_SKIPPED;
1032         }
1033
1034         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1035                 RTE_LOG(INFO, USER1, "Capability requirements for "
1036                                 "Chacha20-Poly1305 testsuite not met\n");
1037                 return TEST_SKIPPED;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int
1044 snow3g_testsuite_setup(void)
1045 {
1046         struct crypto_testsuite_params *ts_params = &testsuite_params;
1047         uint8_t dev_id = ts_params->valid_devs[0];
1048         struct rte_cryptodev_info dev_info;
1049         const enum rte_crypto_cipher_algorithm ciphers[] = {
1050                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1051
1052         };
1053         const enum rte_crypto_auth_algorithm auths[] = {
1054                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1055         };
1056
1057         rte_cryptodev_info_get(dev_id, &dev_info);
1058
1059         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1060                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1061                                 "testsuite not met\n");
1062                 return TEST_SKIPPED;
1063         }
1064
1065         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1066                         && check_auth_capabilities_supported(auths,
1067                         RTE_DIM(auths)) != 0) {
1068                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1069                                 "testsuite not met\n");
1070                 return TEST_SKIPPED;
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int
1077 zuc_testsuite_setup(void)
1078 {
1079         struct crypto_testsuite_params *ts_params = &testsuite_params;
1080         uint8_t dev_id = ts_params->valid_devs[0];
1081         struct rte_cryptodev_info dev_info;
1082         const enum rte_crypto_cipher_algorithm ciphers[] = {
1083                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1084         };
1085         const enum rte_crypto_auth_algorithm auths[] = {
1086                 RTE_CRYPTO_AUTH_ZUC_EIA3
1087         };
1088
1089         rte_cryptodev_info_get(dev_id, &dev_info);
1090
1091         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1092                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1093                                 "testsuite not met\n");
1094                 return TEST_SKIPPED;
1095         }
1096
1097         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1098                         && check_auth_capabilities_supported(auths,
1099                         RTE_DIM(auths)) != 0) {
1100                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1101                                 "testsuite not met\n");
1102                 return TEST_SKIPPED;
1103         }
1104
1105         return 0;
1106 }
1107
1108 static int
1109 hmac_md5_auth_testsuite_setup(void)
1110 {
1111         struct crypto_testsuite_params *ts_params = &testsuite_params;
1112         uint8_t dev_id = ts_params->valid_devs[0];
1113         struct rte_cryptodev_info dev_info;
1114         const enum rte_crypto_auth_algorithm auths[] = {
1115                 RTE_CRYPTO_AUTH_MD5_HMAC
1116         };
1117
1118         rte_cryptodev_info_get(dev_id, &dev_info);
1119
1120         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1121                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1122                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1123                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1124                                 "Auth testsuite not met\n");
1125                 return TEST_SKIPPED;
1126         }
1127
1128         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1129                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1130                                 "testsuite not met\n");
1131                 return TEST_SKIPPED;
1132         }
1133
1134         return 0;
1135 }
1136
1137 static int
1138 kasumi_testsuite_setup(void)
1139 {
1140         struct crypto_testsuite_params *ts_params = &testsuite_params;
1141         uint8_t dev_id = ts_params->valid_devs[0];
1142         struct rte_cryptodev_info dev_info;
1143         const enum rte_crypto_cipher_algorithm ciphers[] = {
1144                 RTE_CRYPTO_CIPHER_KASUMI_F8
1145         };
1146         const enum rte_crypto_auth_algorithm auths[] = {
1147                 RTE_CRYPTO_AUTH_KASUMI_F9
1148         };
1149
1150         rte_cryptodev_info_get(dev_id, &dev_info);
1151
1152         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1153                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1154                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1155                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1156                                 "testsuite not met\n");
1157                 return TEST_SKIPPED;
1158         }
1159
1160         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1161                         && check_auth_capabilities_supported(auths,
1162                         RTE_DIM(auths)) != 0) {
1163                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1164                                 "testsuite not met\n");
1165                 return TEST_SKIPPED;
1166         }
1167
1168         return 0;
1169 }
1170
1171 static int
1172 negative_aes_gcm_testsuite_setup(void)
1173 {
1174         struct crypto_testsuite_params *ts_params = &testsuite_params;
1175         uint8_t dev_id = ts_params->valid_devs[0];
1176         struct rte_cryptodev_info dev_info;
1177         const enum rte_crypto_aead_algorithm aeads[] = {
1178                 RTE_CRYPTO_AEAD_AES_GCM
1179         };
1180
1181         rte_cryptodev_info_get(dev_id, &dev_info);
1182
1183         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1184                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1185                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1186                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1187                                 "AES GCM testsuite not met\n");
1188                 return TEST_SKIPPED;
1189         }
1190
1191         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1192                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1193                                 "AES GCM testsuite not met\n");
1194                 return TEST_SKIPPED;
1195         }
1196
1197         return 0;
1198 }
1199
1200 static int
1201 negative_aes_gmac_testsuite_setup(void)
1202 {
1203         struct crypto_testsuite_params *ts_params = &testsuite_params;
1204         uint8_t dev_id = ts_params->valid_devs[0];
1205         struct rte_cryptodev_info dev_info;
1206         const enum rte_crypto_auth_algorithm auths[] = {
1207                 RTE_CRYPTO_AUTH_AES_GMAC
1208         };
1209
1210         rte_cryptodev_info_get(dev_id, &dev_info);
1211
1212         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1213                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1214                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1215                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1216                                 "AES GMAC testsuite not met\n");
1217                 return TEST_SKIPPED;
1218         }
1219
1220         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1221                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1222                                 "AES GMAC testsuite not met\n");
1223                 return TEST_SKIPPED;
1224         }
1225
1226         return 0;
1227 }
1228
1229 static int
1230 mixed_cipher_hash_testsuite_setup(void)
1231 {
1232         struct crypto_testsuite_params *ts_params = &testsuite_params;
1233         uint8_t dev_id = ts_params->valid_devs[0];
1234         struct rte_cryptodev_info dev_info;
1235         uint64_t feat_flags;
1236         const enum rte_crypto_cipher_algorithm ciphers[] = {
1237                 RTE_CRYPTO_CIPHER_NULL,
1238                 RTE_CRYPTO_CIPHER_AES_CTR,
1239                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1240                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1241         };
1242         const enum rte_crypto_auth_algorithm auths[] = {
1243                 RTE_CRYPTO_AUTH_NULL,
1244                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1245                 RTE_CRYPTO_AUTH_AES_CMAC,
1246                 RTE_CRYPTO_AUTH_ZUC_EIA3
1247         };
1248
1249         rte_cryptodev_info_get(dev_id, &dev_info);
1250         feat_flags = dev_info.feature_flags;
1251
1252         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1253                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1254                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1255                                 "Cipher Hash testsuite not met\n");
1256                 return TEST_SKIPPED;
1257         }
1258
1259         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1260                         && check_auth_capabilities_supported(auths,
1261                         RTE_DIM(auths)) != 0) {
1262                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1263                                 "Cipher Hash testsuite not met\n");
1264                 return TEST_SKIPPED;
1265         }
1266
1267         return 0;
1268 }
1269
1270 static int
1271 esn_testsuite_setup(void)
1272 {
1273         struct crypto_testsuite_params *ts_params = &testsuite_params;
1274         uint8_t dev_id = ts_params->valid_devs[0];
1275         struct rte_cryptodev_info dev_info;
1276         const enum rte_crypto_cipher_algorithm ciphers[] = {
1277                 RTE_CRYPTO_CIPHER_AES_CBC
1278         };
1279         const enum rte_crypto_auth_algorithm auths[] = {
1280                 RTE_CRYPTO_AUTH_SHA1_HMAC
1281         };
1282
1283         rte_cryptodev_info_get(dev_id, &dev_info);
1284
1285         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1286                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1287                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1288                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1289                                 "testsuite not met\n");
1290                 return TEST_SKIPPED;
1291         }
1292
1293         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1294                         && check_auth_capabilities_supported(auths,
1295                         RTE_DIM(auths)) != 0) {
1296                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1297                                 "testsuite not met\n");
1298                 return TEST_SKIPPED;
1299         }
1300
1301         return 0;
1302 }
1303
1304 static int
1305 multi_session_testsuite_setup(void)
1306 {
1307         struct crypto_testsuite_params *ts_params = &testsuite_params;
1308         uint8_t dev_id = ts_params->valid_devs[0];
1309         struct rte_cryptodev_info dev_info;
1310         const enum rte_crypto_cipher_algorithm ciphers[] = {
1311                 RTE_CRYPTO_CIPHER_AES_CBC
1312         };
1313         const enum rte_crypto_auth_algorithm auths[] = {
1314                 RTE_CRYPTO_AUTH_SHA512_HMAC
1315         };
1316
1317         rte_cryptodev_info_get(dev_id, &dev_info);
1318
1319         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1320                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1321                                 "Session testsuite not met\n");
1322                 return TEST_SKIPPED;
1323         }
1324
1325         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1326                         && check_auth_capabilities_supported(auths,
1327                         RTE_DIM(auths)) != 0) {
1328                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1329                                 "Session testsuite not met\n");
1330                 return TEST_SKIPPED;
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int
1337 negative_hmac_sha1_testsuite_setup(void)
1338 {
1339         struct crypto_testsuite_params *ts_params = &testsuite_params;
1340         uint8_t dev_id = ts_params->valid_devs[0];
1341         struct rte_cryptodev_info dev_info;
1342         const enum rte_crypto_cipher_algorithm ciphers[] = {
1343                 RTE_CRYPTO_CIPHER_AES_CBC
1344         };
1345         const enum rte_crypto_auth_algorithm auths[] = {
1346                 RTE_CRYPTO_AUTH_SHA1_HMAC
1347         };
1348
1349         rte_cryptodev_info_get(dev_id, &dev_info);
1350
1351         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1352                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1353                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1354                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1355                                 "HMAC SHA1 testsuite not met\n");
1356                 return TEST_SKIPPED;
1357         }
1358
1359         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1360                         && check_auth_capabilities_supported(auths,
1361                         RTE_DIM(auths)) != 0) {
1362                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1363                                 "HMAC SHA1 testsuite not met\n");
1364                 return TEST_SKIPPED;
1365         }
1366
1367         return 0;
1368 }
1369
1370 static int
1371 dev_configure_and_start(uint64_t ff_disable)
1372 {
1373         struct crypto_testsuite_params *ts_params = &testsuite_params;
1374         struct crypto_unittest_params *ut_params = &unittest_params;
1375
1376         uint16_t qp_id;
1377
1378         /* Clear unit test parameters before running test */
1379         memset(ut_params, 0, sizeof(*ut_params));
1380
1381         /* Reconfigure device to default parameters */
1382         ts_params->conf.socket_id = SOCKET_ID_ANY;
1383         ts_params->conf.ff_disable = ff_disable;
1384         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1385         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1386         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1387
1388         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1389                         &ts_params->conf),
1390                         "Failed to configure cryptodev %u",
1391                         ts_params->valid_devs[0]);
1392
1393         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1394                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1395                         ts_params->valid_devs[0], qp_id,
1396                         &ts_params->qp_conf,
1397                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1398                         "Failed to setup queue pair %u on cryptodev %u",
1399                         qp_id, ts_params->valid_devs[0]);
1400         }
1401
1402
1403         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1404
1405         /* Start the device */
1406         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1407                         "Failed to start cryptodev %u",
1408                         ts_params->valid_devs[0]);
1409
1410         return TEST_SUCCESS;
1411 }
1412
1413 int
1414 ut_setup(void)
1415 {
1416         /* Configure and start the device with security feature disabled */
1417         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1418 }
1419
1420 static int
1421 ut_setup_security(void)
1422 {
1423         /* Configure and start the device with no features disabled */
1424         return dev_configure_and_start(0);
1425 }
1426
1427 void
1428 ut_teardown(void)
1429 {
1430         struct crypto_testsuite_params *ts_params = &testsuite_params;
1431         struct crypto_unittest_params *ut_params = &unittest_params;
1432
1433         /* free crypto session structure */
1434 #ifdef RTE_LIB_SECURITY
1435         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1436                 if (ut_params->sec_session) {
1437                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1438                                                 (ts_params->valid_devs[0]),
1439                                                 ut_params->sec_session);
1440                         ut_params->sec_session = NULL;
1441                 }
1442         } else
1443 #endif
1444         {
1445                 if (ut_params->sess) {
1446                         rte_cryptodev_sym_session_clear(
1447                                         ts_params->valid_devs[0],
1448                                         ut_params->sess);
1449                         rte_cryptodev_sym_session_free(ut_params->sess);
1450                         ut_params->sess = NULL;
1451                 }
1452         }
1453
1454         /* free crypto operation structure */
1455         if (ut_params->op)
1456                 rte_crypto_op_free(ut_params->op);
1457
1458         /*
1459          * free mbuf - both obuf and ibuf are usually the same,
1460          * so check if they point at the same address is necessary,
1461          * to avoid freeing the mbuf twice.
1462          */
1463         if (ut_params->obuf) {
1464                 rte_pktmbuf_free(ut_params->obuf);
1465                 if (ut_params->ibuf == ut_params->obuf)
1466                         ut_params->ibuf = 0;
1467                 ut_params->obuf = 0;
1468         }
1469         if (ut_params->ibuf) {
1470                 rte_pktmbuf_free(ut_params->ibuf);
1471                 ut_params->ibuf = 0;
1472         }
1473
1474         if (ts_params->mbuf_pool != NULL)
1475                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1476                         rte_mempool_avail_count(ts_params->mbuf_pool));
1477
1478         /* Stop the device */
1479         rte_cryptodev_stop(ts_params->valid_devs[0]);
1480 }
1481
1482 static int
1483 test_device_configure_invalid_dev_id(void)
1484 {
1485         struct crypto_testsuite_params *ts_params = &testsuite_params;
1486         uint16_t dev_id, num_devs = 0;
1487
1488         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1489                         "Need at least %d devices for test", 1);
1490
1491         /* valid dev_id values */
1492         dev_id = ts_params->valid_devs[0];
1493
1494         /* Stop the device in case it's started so it can be configured */
1495         rte_cryptodev_stop(dev_id);
1496
1497         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1498                         "Failed test for rte_cryptodev_configure: "
1499                         "invalid dev_num %u", dev_id);
1500
1501         /* invalid dev_id values */
1502         dev_id = num_devs;
1503
1504         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1505                         "Failed test for rte_cryptodev_configure: "
1506                         "invalid dev_num %u", dev_id);
1507
1508         dev_id = 0xff;
1509
1510         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1511                         "Failed test for rte_cryptodev_configure:"
1512                         "invalid dev_num %u", dev_id);
1513
1514         return TEST_SUCCESS;
1515 }
1516
1517 static int
1518 test_device_configure_invalid_queue_pair_ids(void)
1519 {
1520         struct crypto_testsuite_params *ts_params = &testsuite_params;
1521         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1522
1523         /* Stop the device in case it's started so it can be configured */
1524         rte_cryptodev_stop(ts_params->valid_devs[0]);
1525
1526         /* valid - max value queue pairs */
1527         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1528
1529         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1530                         &ts_params->conf),
1531                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1532                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1533
1534         /* valid - one queue pairs */
1535         ts_params->conf.nb_queue_pairs = 1;
1536
1537         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1538                         &ts_params->conf),
1539                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1540                         ts_params->valid_devs[0],
1541                         ts_params->conf.nb_queue_pairs);
1542
1543
1544         /* invalid - zero queue pairs */
1545         ts_params->conf.nb_queue_pairs = 0;
1546
1547         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1548                         &ts_params->conf),
1549                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1550                         " invalid qps: %u",
1551                         ts_params->valid_devs[0],
1552                         ts_params->conf.nb_queue_pairs);
1553
1554
1555         /* invalid - max value supported by field queue pairs */
1556         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1557
1558         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1559                         &ts_params->conf),
1560                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1561                         " invalid qps: %u",
1562                         ts_params->valid_devs[0],
1563                         ts_params->conf.nb_queue_pairs);
1564
1565
1566         /* invalid - max value + 1 queue pairs */
1567         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1568
1569         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1570                         &ts_params->conf),
1571                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1572                         " invalid qps: %u",
1573                         ts_params->valid_devs[0],
1574                         ts_params->conf.nb_queue_pairs);
1575
1576         /* revert to original testsuite value */
1577         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1578
1579         return TEST_SUCCESS;
1580 }
1581
1582 static int
1583 test_queue_pair_descriptor_setup(void)
1584 {
1585         struct crypto_testsuite_params *ts_params = &testsuite_params;
1586         struct rte_cryptodev_qp_conf qp_conf = {
1587                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1588         };
1589         uint16_t qp_id;
1590
1591         /* Stop the device in case it's started so it can be configured */
1592         rte_cryptodev_stop(ts_params->valid_devs[0]);
1593
1594         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1595                         &ts_params->conf),
1596                         "Failed to configure cryptodev %u",
1597                         ts_params->valid_devs[0]);
1598
1599         /*
1600          * Test various ring sizes on this device. memzones can't be
1601          * freed so are re-used if ring is released and re-created.
1602          */
1603         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1604         qp_conf.mp_session = ts_params->session_mpool;
1605         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1606
1607         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1608                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1609                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1610                                 rte_cryptodev_socket_id(
1611                                                 ts_params->valid_devs[0])),
1612                                 "Failed test for "
1613                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1614                                 "%u on qp %u on cryptodev %u",
1615                                 qp_conf.nb_descriptors, qp_id,
1616                                 ts_params->valid_devs[0]);
1617         }
1618
1619         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1620
1621         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1622                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1623                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1624                                 rte_cryptodev_socket_id(
1625                                                 ts_params->valid_devs[0])),
1626                                 "Failed test for"
1627                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1628                                 " %u on qp %u on cryptodev %u",
1629                                 qp_conf.nb_descriptors, qp_id,
1630                                 ts_params->valid_devs[0]);
1631         }
1632
1633         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1634
1635         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1636                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1637                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1638                                 rte_cryptodev_socket_id(
1639                                                 ts_params->valid_devs[0])),
1640                                 "Failed test for "
1641                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1642                                 " %u on qp %u on cryptodev %u",
1643                                 qp_conf.nb_descriptors, qp_id,
1644                                 ts_params->valid_devs[0]);
1645         }
1646
1647         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1648
1649         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1650                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1651                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1652                                 rte_cryptodev_socket_id(
1653                                                 ts_params->valid_devs[0])),
1654                                 "Failed test for"
1655                                 " rte_cryptodev_queue_pair_setup:"
1656                                 "num_inflights %u on qp %u on cryptodev %u",
1657                                 qp_conf.nb_descriptors, qp_id,
1658                                 ts_params->valid_devs[0]);
1659         }
1660
1661         /* test invalid queue pair id */
1662         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1663
1664         qp_id = ts_params->conf.nb_queue_pairs;         /*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         qp_id = 0xffff; /*invalid*/
1675
1676         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1677                         ts_params->valid_devs[0],
1678                         qp_id, &qp_conf,
1679                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1680                         "Failed test for rte_cryptodev_queue_pair_setup:"
1681                         "invalid qp %u on cryptodev %u",
1682                         qp_id, ts_params->valid_devs[0]);
1683
1684         return TEST_SUCCESS;
1685 }
1686
1687 /* ***** Plaintext data for tests ***** */
1688
1689 const char catch_22_quote_1[] =
1690                 "There was only one catch and that was Catch-22, which "
1691                 "specified that a concern for one's safety in the face of "
1692                 "dangers that were real and immediate was the process of a "
1693                 "rational mind. Orr was crazy and could be grounded. All he "
1694                 "had to do was ask; and as soon as he did, he would no longer "
1695                 "be crazy and would have to fly more missions. Orr would be "
1696                 "crazy to fly more missions and sane if he didn't, but if he "
1697                 "was sane he had to fly them. If he flew them he was crazy "
1698                 "and didn't have to; but if he didn't want to he was sane and "
1699                 "had to. Yossarian was moved very deeply by the absolute "
1700                 "simplicity of this clause of Catch-22 and let out a "
1701                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1702                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1703
1704 const char catch_22_quote[] =
1705                 "What a lousy earth! He wondered how many people were "
1706                 "destitute that same night even in his own prosperous country, "
1707                 "how many homes were shanties, how many husbands were drunk "
1708                 "and wives socked, and how many children were bullied, abused, "
1709                 "or abandoned. How many families hungered for food they could "
1710                 "not afford to buy? How many hearts were broken? How many "
1711                 "suicides would take place that same night, how many people "
1712                 "would go insane? How many cockroaches and landlords would "
1713                 "triumph? How many winners were losers, successes failures, "
1714                 "and rich men poor men? How many wise guys were stupid? How "
1715                 "many happy endings were unhappy endings? How many honest men "
1716                 "were liars, brave men cowards, loyal men traitors, how many "
1717                 "sainted men were corrupt, how many people in positions of "
1718                 "trust had sold their souls to bodyguards, how many had never "
1719                 "had souls? How many straight-and-narrow paths were crooked "
1720                 "paths? How many best families were worst families and how "
1721                 "many good people were bad people? When you added them all up "
1722                 "and then subtracted, you might be left with only the children, "
1723                 "and perhaps with Albert Einstein and an old violinist or "
1724                 "sculptor somewhere.";
1725
1726 #define QUOTE_480_BYTES         (480)
1727 #define QUOTE_512_BYTES         (512)
1728 #define QUOTE_768_BYTES         (768)
1729 #define QUOTE_1024_BYTES        (1024)
1730
1731
1732
1733 /* ***** SHA1 Hash Tests ***** */
1734
1735 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1736
1737 static uint8_t hmac_sha1_key[] = {
1738         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1739         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1740         0xDE, 0xF4, 0xDE, 0xAD };
1741
1742 /* ***** SHA224 Hash Tests ***** */
1743
1744 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1745
1746
1747 /* ***** AES-CBC Cipher Tests ***** */
1748
1749 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1750 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1751
1752 static uint8_t aes_cbc_key[] = {
1753         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1754         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1755
1756 static uint8_t aes_cbc_iv[] = {
1757         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1758         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1759
1760
1761 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1762
1763 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1764         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1765         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1766         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1767         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1768         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1769         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1770         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1771         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1772         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1773         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1774         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1775         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1776         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1777         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1778         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1779         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1780         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1781         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1782         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1783         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1784         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1785         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1786         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1787         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1788         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1789         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1790         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1791         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1792         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1793         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1794         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1795         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1796         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1797         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1798         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1799         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1800         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1801         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1802         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1803         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1804         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1805         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1806         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1807         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1808         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1809         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1810         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1811         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1812         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1813         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1814         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1815         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1816         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1817         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1818         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1819         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1820         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1821         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1822         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1823         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1824         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1825         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1826         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1827         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1828 };
1829
1830 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1831         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1832         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1833         0x18, 0x8c, 0x1d, 0x32
1834 };
1835
1836
1837 /* Multisession Vector context Test */
1838 /*Begin Session 0 */
1839 static uint8_t ms_aes_cbc_key0[] = {
1840         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1841         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1842 };
1843
1844 static uint8_t ms_aes_cbc_iv0[] = {
1845         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1846         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1847 };
1848
1849 static const uint8_t ms_aes_cbc_cipher0[] = {
1850                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1851                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1852                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1853                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1854                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1855                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1856                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1857                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1858                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1859                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1860                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1861                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1862                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1863                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1864                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1865                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1866                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1867                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1868                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1869                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1870                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1871                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1872                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1873                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1874                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1875                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1876                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1877                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1878                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1879                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1880                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1881                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1882                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1883                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1884                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1885                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1886                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1887                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1888                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1889                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1890                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1891                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1892                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1893                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1894                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1895                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1896                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1897                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1898                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1899                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1900                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1901                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1902                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1903                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1904                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1905                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1906                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1907                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1908                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1909                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1910                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1911                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1912                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1913                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1914 };
1915
1916
1917 static  uint8_t ms_hmac_key0[] = {
1918                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1919                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1920                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1921                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1922                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1923                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1924                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1925                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1926 };
1927
1928 static const uint8_t ms_hmac_digest0[] = {
1929                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1930                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1931                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1932                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1933                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1934                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1935                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1936                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1937                 };
1938
1939 /* End Session 0 */
1940 /* Begin session 1 */
1941
1942 static  uint8_t ms_aes_cbc_key1[] = {
1943                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1944                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1945 };
1946
1947 static  uint8_t ms_aes_cbc_iv1[] = {
1948         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1949         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1950 };
1951
1952 static const uint8_t ms_aes_cbc_cipher1[] = {
1953                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1954                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1955                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1956                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1957                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1958                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1959                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1960                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1961                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1962                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1963                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1964                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1965                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1966                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1967                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1968                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1969                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1970                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1971                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1972                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1973                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1974                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1975                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1976                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1977                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1978                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1979                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1980                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1981                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1982                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1983                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1984                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1985                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1986                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1987                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1988                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1989                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1990                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1991                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1992                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1993                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1994                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1995                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1996                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1997                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1998                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1999                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
2000                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
2001                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
2002                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
2003                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
2004                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
2005                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
2006                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
2007                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
2008                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2009                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2010                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2011                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2012                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2013                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2014                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2015                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2016                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2017
2018 };
2019
2020 static uint8_t ms_hmac_key1[] = {
2021                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2022                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2023                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2024                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2025                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2026                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2027                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2028                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2029 };
2030
2031 static const uint8_t ms_hmac_digest1[] = {
2032                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2033                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2034                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2035                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2036                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2037                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2038                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2039                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2040 };
2041 /* End Session 1  */
2042 /* Begin Session 2 */
2043 static  uint8_t ms_aes_cbc_key2[] = {
2044                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2045                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2046 };
2047
2048 static  uint8_t ms_aes_cbc_iv2[] = {
2049                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2050                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2051 };
2052
2053 static const uint8_t ms_aes_cbc_cipher2[] = {
2054                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2055                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2056                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2057                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2058                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2059                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2060                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2061                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2062                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2063                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2064                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2065                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2066                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2067                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2068                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2069                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2070                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2071                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2072                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2073                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2074                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2075                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2076                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2077                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2078                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2079                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2080                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2081                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2082                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2083                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2084                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2085                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2086                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2087                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2088                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2089                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2090                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2091                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2092                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2093                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2094                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2095                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2096                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2097                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2098                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2099                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2100                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2101                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2102                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2103                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2104                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2105                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2106                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2107                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2108                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2109                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2110                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2111                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2112                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2113                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2114                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2115                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2116                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2117                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2118 };
2119
2120 static  uint8_t ms_hmac_key2[] = {
2121                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2122                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2123                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2124                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2125                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2126                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2127                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2128                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2129 };
2130
2131 static const uint8_t ms_hmac_digest2[] = {
2132                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2133                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2134                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2135                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2136                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2137                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2138                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2139                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2140 };
2141
2142 /* End Session 2 */
2143
2144
2145 static int
2146 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2147 {
2148         struct crypto_testsuite_params *ts_params = &testsuite_params;
2149         struct crypto_unittest_params *ut_params = &unittest_params;
2150         int status;
2151
2152         /* Verify the capabilities */
2153         struct rte_cryptodev_sym_capability_idx cap_idx;
2154         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2155         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2156         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2157                         &cap_idx) == NULL)
2158                 return TEST_SKIPPED;
2159         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2160         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2161         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2162                         &cap_idx) == NULL)
2163                 return TEST_SKIPPED;
2164
2165         /* Generate test mbuf data and space for digest */
2166         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2167                         catch_22_quote, QUOTE_512_BYTES, 0);
2168
2169         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2170                         DIGEST_BYTE_LENGTH_SHA1);
2171         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2172
2173         /* Setup Cipher Parameters */
2174         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2175         ut_params->cipher_xform.next = &ut_params->auth_xform;
2176
2177         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2178         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2179         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2180         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2181         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2182         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2183
2184         /* Setup HMAC Parameters */
2185         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2186
2187         ut_params->auth_xform.next = NULL;
2188
2189         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2190         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2191         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2192         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2193         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2194
2195         ut_params->sess = rte_cryptodev_sym_session_create(
2196                         ts_params->session_mpool);
2197         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2198
2199         /* Create crypto session*/
2200         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2201                         ut_params->sess, &ut_params->cipher_xform,
2202                         ts_params->session_priv_mpool);
2203
2204         if (status == -ENOTSUP)
2205                 return TEST_SKIPPED;
2206
2207         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2208
2209         /* Generate crypto op data structure */
2210         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2211                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2212         TEST_ASSERT_NOT_NULL(ut_params->op,
2213                         "Failed to allocate symmetric crypto operation struct");
2214
2215         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2216
2217         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2218
2219         /* set crypto operation source mbuf */
2220         sym_op->m_src = ut_params->ibuf;
2221
2222         /* Set crypto operation authentication parameters */
2223         sym_op->auth.digest.data = ut_params->digest;
2224         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2225                         ut_params->ibuf, QUOTE_512_BYTES);
2226
2227         sym_op->auth.data.offset = 0;
2228         sym_op->auth.data.length = QUOTE_512_BYTES;
2229
2230         /* Copy IV at the end of the crypto operation */
2231         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2232                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2233
2234         /* Set crypto operation cipher parameters */
2235         sym_op->cipher.data.offset = 0;
2236         sym_op->cipher.data.length = QUOTE_512_BYTES;
2237
2238         /* Process crypto operation */
2239         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2240                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2241                         ut_params->op);
2242         else
2243                 TEST_ASSERT_NOT_NULL(
2244                         process_crypto_request(ts_params->valid_devs[0],
2245                                 ut_params->op),
2246                                 "failed to process sym crypto op");
2247
2248         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2249                         "crypto op processing failed");
2250
2251         /* Validate obuf */
2252         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2253                         uint8_t *);
2254
2255         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2256                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2257                         QUOTE_512_BYTES,
2258                         "ciphertext data not as expected");
2259
2260         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2261
2262         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2263                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2264                         gbl_driver_id == rte_cryptodev_driver_id_get(
2265                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2266                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2267                                         DIGEST_BYTE_LENGTH_SHA1,
2268                         "Generated digest data not as expected");
2269
2270         return TEST_SUCCESS;
2271 }
2272
2273 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2274
2275 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2276
2277 static uint8_t hmac_sha512_key[] = {
2278         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2279         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2280         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2281         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2282         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2283         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2284         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2285         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2286
2287 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2288         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2289         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2290         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2291         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2292         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2293         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2294         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2295         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2296
2297
2298
2299 static int
2300 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2301                 struct crypto_unittest_params *ut_params,
2302                 uint8_t *cipher_key,
2303                 uint8_t *hmac_key);
2304
2305 static int
2306 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2307                 struct crypto_unittest_params *ut_params,
2308                 struct crypto_testsuite_params *ts_params,
2309                 const uint8_t *cipher,
2310                 const uint8_t *digest,
2311                 const uint8_t *iv);
2312
2313
2314 static int
2315 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2316                 struct crypto_unittest_params *ut_params,
2317                 uint8_t *cipher_key,
2318                 uint8_t *hmac_key)
2319 {
2320
2321         /* Setup Cipher Parameters */
2322         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2323         ut_params->cipher_xform.next = NULL;
2324
2325         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2326         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2327         ut_params->cipher_xform.cipher.key.data = cipher_key;
2328         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2329         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2330         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2331
2332         /* Setup HMAC Parameters */
2333         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2334         ut_params->auth_xform.next = &ut_params->cipher_xform;
2335
2336         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2337         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2338         ut_params->auth_xform.auth.key.data = hmac_key;
2339         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2340         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2341
2342         return TEST_SUCCESS;
2343 }
2344
2345
2346 static int
2347 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2348                 struct crypto_unittest_params *ut_params,
2349                 struct crypto_testsuite_params *ts_params,
2350                 const uint8_t *cipher,
2351                 const uint8_t *digest,
2352                 const uint8_t *iv)
2353 {
2354         /* Generate test mbuf data and digest */
2355         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2356                         (const char *)
2357                         cipher,
2358                         QUOTE_512_BYTES, 0);
2359
2360         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2361                         DIGEST_BYTE_LENGTH_SHA512);
2362         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2363
2364         rte_memcpy(ut_params->digest,
2365                         digest,
2366                         DIGEST_BYTE_LENGTH_SHA512);
2367
2368         /* Generate Crypto op data structure */
2369         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2370                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2371         TEST_ASSERT_NOT_NULL(ut_params->op,
2372                         "Failed to allocate symmetric crypto operation struct");
2373
2374         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2375
2376         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2377
2378         /* set crypto operation source mbuf */
2379         sym_op->m_src = ut_params->ibuf;
2380
2381         sym_op->auth.digest.data = ut_params->digest;
2382         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2383                         ut_params->ibuf, QUOTE_512_BYTES);
2384
2385         sym_op->auth.data.offset = 0;
2386         sym_op->auth.data.length = QUOTE_512_BYTES;
2387
2388         /* Copy IV at the end of the crypto operation */
2389         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2390                         iv, CIPHER_IV_LENGTH_AES_CBC);
2391
2392         sym_op->cipher.data.offset = 0;
2393         sym_op->cipher.data.length = QUOTE_512_BYTES;
2394
2395         /* Process crypto operation */
2396         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2397                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2398                         ut_params->op);
2399         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2400                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2401                                 ut_params->op, 1, 1, 0, 0);
2402         else
2403                 TEST_ASSERT_NOT_NULL(
2404                                 process_crypto_request(ts_params->valid_devs[0],
2405                                         ut_params->op),
2406                                         "failed to process sym crypto op");
2407
2408         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2409                         "crypto op processing failed");
2410
2411         ut_params->obuf = ut_params->op->sym->m_src;
2412
2413         /* Validate obuf */
2414         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2415                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2416                         catch_22_quote,
2417                         QUOTE_512_BYTES,
2418                         "Plaintext data not as expected");
2419
2420         /* Validate obuf */
2421         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2422                         "Digest verification failed");
2423
2424         return TEST_SUCCESS;
2425 }
2426
2427 /* ***** SNOW 3G Tests ***** */
2428 static int
2429 create_wireless_algo_hash_session(uint8_t dev_id,
2430         const uint8_t *key, const uint8_t key_len,
2431         const uint8_t iv_len, const uint8_t auth_len,
2432         enum rte_crypto_auth_operation op,
2433         enum rte_crypto_auth_algorithm algo)
2434 {
2435         uint8_t hash_key[key_len];
2436         int status;
2437
2438         struct crypto_testsuite_params *ts_params = &testsuite_params;
2439         struct crypto_unittest_params *ut_params = &unittest_params;
2440
2441         memcpy(hash_key, key, key_len);
2442
2443         debug_hexdump(stdout, "key:", key, key_len);
2444
2445         /* Setup Authentication Parameters */
2446         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2447         ut_params->auth_xform.next = NULL;
2448
2449         ut_params->auth_xform.auth.op = op;
2450         ut_params->auth_xform.auth.algo = algo;
2451         ut_params->auth_xform.auth.key.length = key_len;
2452         ut_params->auth_xform.auth.key.data = hash_key;
2453         ut_params->auth_xform.auth.digest_length = auth_len;
2454         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2455         ut_params->auth_xform.auth.iv.length = iv_len;
2456         ut_params->sess = rte_cryptodev_sym_session_create(
2457                         ts_params->session_mpool);
2458
2459         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2460                         &ut_params->auth_xform,
2461                         ts_params->session_priv_mpool);
2462         if (status == -ENOTSUP)
2463                 return TEST_SKIPPED;
2464
2465         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2466         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2467         return 0;
2468 }
2469
2470 static int
2471 create_wireless_algo_cipher_session(uint8_t dev_id,
2472                         enum rte_crypto_cipher_operation op,
2473                         enum rte_crypto_cipher_algorithm algo,
2474                         const uint8_t *key, const uint8_t key_len,
2475                         uint8_t iv_len)
2476 {
2477         uint8_t cipher_key[key_len];
2478         int status;
2479         struct crypto_testsuite_params *ts_params = &testsuite_params;
2480         struct crypto_unittest_params *ut_params = &unittest_params;
2481
2482         memcpy(cipher_key, key, key_len);
2483
2484         /* Setup Cipher Parameters */
2485         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2486         ut_params->cipher_xform.next = NULL;
2487
2488         ut_params->cipher_xform.cipher.algo = algo;
2489         ut_params->cipher_xform.cipher.op = op;
2490         ut_params->cipher_xform.cipher.key.data = cipher_key;
2491         ut_params->cipher_xform.cipher.key.length = key_len;
2492         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2493         ut_params->cipher_xform.cipher.iv.length = iv_len;
2494
2495         debug_hexdump(stdout, "key:", key, key_len);
2496
2497         /* Create Crypto session */
2498         ut_params->sess = rte_cryptodev_sym_session_create(
2499                         ts_params->session_mpool);
2500
2501         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2502                         &ut_params->cipher_xform,
2503                         ts_params->session_priv_mpool);
2504         if (status == -ENOTSUP)
2505                 return TEST_SKIPPED;
2506
2507         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2508         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2509         return 0;
2510 }
2511
2512 static int
2513 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2514                         unsigned int cipher_len,
2515                         unsigned int cipher_offset)
2516 {
2517         struct crypto_testsuite_params *ts_params = &testsuite_params;
2518         struct crypto_unittest_params *ut_params = &unittest_params;
2519
2520         /* Generate Crypto op data structure */
2521         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2522                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2523         TEST_ASSERT_NOT_NULL(ut_params->op,
2524                                 "Failed to allocate pktmbuf offload");
2525
2526         /* Set crypto operation data parameters */
2527         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2528
2529         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2530
2531         /* set crypto operation source mbuf */
2532         sym_op->m_src = ut_params->ibuf;
2533
2534         /* iv */
2535         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2536                         iv, iv_len);
2537         sym_op->cipher.data.length = cipher_len;
2538         sym_op->cipher.data.offset = cipher_offset;
2539         return 0;
2540 }
2541
2542 static int
2543 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2544                         unsigned int cipher_len,
2545                         unsigned int cipher_offset)
2546 {
2547         struct crypto_testsuite_params *ts_params = &testsuite_params;
2548         struct crypto_unittest_params *ut_params = &unittest_params;
2549
2550         /* Generate Crypto op data structure */
2551         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2552                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2553         TEST_ASSERT_NOT_NULL(ut_params->op,
2554                                 "Failed to allocate pktmbuf offload");
2555
2556         /* Set crypto operation data parameters */
2557         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2558
2559         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2560
2561         /* set crypto operation source mbuf */
2562         sym_op->m_src = ut_params->ibuf;
2563         sym_op->m_dst = ut_params->obuf;
2564
2565         /* iv */
2566         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2567                         iv, iv_len);
2568         sym_op->cipher.data.length = cipher_len;
2569         sym_op->cipher.data.offset = cipher_offset;
2570         return 0;
2571 }
2572
2573 static int
2574 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2575                 enum rte_crypto_cipher_operation cipher_op,
2576                 enum rte_crypto_auth_operation auth_op,
2577                 enum rte_crypto_auth_algorithm auth_algo,
2578                 enum rte_crypto_cipher_algorithm cipher_algo,
2579                 const uint8_t *key, uint8_t key_len,
2580                 uint8_t auth_iv_len, uint8_t auth_len,
2581                 uint8_t cipher_iv_len)
2582
2583 {
2584         uint8_t cipher_auth_key[key_len];
2585         int status;
2586
2587         struct crypto_testsuite_params *ts_params = &testsuite_params;
2588         struct crypto_unittest_params *ut_params = &unittest_params;
2589
2590         memcpy(cipher_auth_key, key, key_len);
2591
2592         /* Setup Authentication Parameters */
2593         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2594         ut_params->auth_xform.next = NULL;
2595
2596         ut_params->auth_xform.auth.op = auth_op;
2597         ut_params->auth_xform.auth.algo = auth_algo;
2598         ut_params->auth_xform.auth.key.length = key_len;
2599         /* Hash key = cipher key */
2600         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2601         ut_params->auth_xform.auth.digest_length = auth_len;
2602         /* Auth IV will be after cipher IV */
2603         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2604         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2605
2606         /* Setup Cipher Parameters */
2607         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2608         ut_params->cipher_xform.next = &ut_params->auth_xform;
2609
2610         ut_params->cipher_xform.cipher.algo = cipher_algo;
2611         ut_params->cipher_xform.cipher.op = cipher_op;
2612         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2613         ut_params->cipher_xform.cipher.key.length = key_len;
2614         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2615         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2616
2617         debug_hexdump(stdout, "key:", key, key_len);
2618
2619         /* Create Crypto session*/
2620         ut_params->sess = rte_cryptodev_sym_session_create(
2621                         ts_params->session_mpool);
2622         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2623
2624         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2625                         &ut_params->cipher_xform,
2626                         ts_params->session_priv_mpool);
2627         if (status == -ENOTSUP)
2628                 return TEST_SKIPPED;
2629
2630         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2631         return 0;
2632 }
2633
2634 static int
2635 create_wireless_cipher_auth_session(uint8_t dev_id,
2636                 enum rte_crypto_cipher_operation cipher_op,
2637                 enum rte_crypto_auth_operation auth_op,
2638                 enum rte_crypto_auth_algorithm auth_algo,
2639                 enum rte_crypto_cipher_algorithm cipher_algo,
2640                 const struct wireless_test_data *tdata)
2641 {
2642         const uint8_t key_len = tdata->key.len;
2643         uint8_t cipher_auth_key[key_len];
2644         int status;
2645
2646         struct crypto_testsuite_params *ts_params = &testsuite_params;
2647         struct crypto_unittest_params *ut_params = &unittest_params;
2648         const uint8_t *key = tdata->key.data;
2649         const uint8_t auth_len = tdata->digest.len;
2650         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2651         uint8_t auth_iv_len = tdata->auth_iv.len;
2652
2653         memcpy(cipher_auth_key, key, key_len);
2654
2655         /* Setup Authentication Parameters */
2656         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2657         ut_params->auth_xform.next = NULL;
2658
2659         ut_params->auth_xform.auth.op = auth_op;
2660         ut_params->auth_xform.auth.algo = auth_algo;
2661         ut_params->auth_xform.auth.key.length = key_len;
2662         /* Hash key = cipher key */
2663         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2664         ut_params->auth_xform.auth.digest_length = auth_len;
2665         /* Auth IV will be after cipher IV */
2666         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2667         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2668
2669         /* Setup Cipher Parameters */
2670         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2671         ut_params->cipher_xform.next = &ut_params->auth_xform;
2672
2673         ut_params->cipher_xform.cipher.algo = cipher_algo;
2674         ut_params->cipher_xform.cipher.op = cipher_op;
2675         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2676         ut_params->cipher_xform.cipher.key.length = key_len;
2677         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2678         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2679
2680
2681         debug_hexdump(stdout, "key:", key, key_len);
2682
2683         /* Create Crypto session*/
2684         ut_params->sess = rte_cryptodev_sym_session_create(
2685                         ts_params->session_mpool);
2686
2687         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2688                         &ut_params->cipher_xform,
2689                         ts_params->session_priv_mpool);
2690         if (status == -ENOTSUP)
2691                 return TEST_SKIPPED;
2692
2693         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2694         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2695         return 0;
2696 }
2697
2698 static int
2699 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2700                 const struct wireless_test_data *tdata)
2701 {
2702         return create_wireless_cipher_auth_session(dev_id,
2703                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2704                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2705                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2706 }
2707
2708 static int
2709 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2710                 enum rte_crypto_cipher_operation cipher_op,
2711                 enum rte_crypto_auth_operation auth_op,
2712                 enum rte_crypto_auth_algorithm auth_algo,
2713                 enum rte_crypto_cipher_algorithm cipher_algo,
2714                 const uint8_t *key, const uint8_t key_len,
2715                 uint8_t auth_iv_len, uint8_t auth_len,
2716                 uint8_t cipher_iv_len)
2717 {
2718         uint8_t auth_cipher_key[key_len];
2719         int status;
2720         struct crypto_testsuite_params *ts_params = &testsuite_params;
2721         struct crypto_unittest_params *ut_params = &unittest_params;
2722
2723         memcpy(auth_cipher_key, key, key_len);
2724
2725         /* Setup Authentication Parameters */
2726         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2727         ut_params->auth_xform.auth.op = auth_op;
2728         ut_params->auth_xform.next = &ut_params->cipher_xform;
2729         ut_params->auth_xform.auth.algo = auth_algo;
2730         ut_params->auth_xform.auth.key.length = key_len;
2731         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2732         ut_params->auth_xform.auth.digest_length = auth_len;
2733         /* Auth IV will be after cipher IV */
2734         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2735         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2736
2737         /* Setup Cipher Parameters */
2738         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2739         ut_params->cipher_xform.next = NULL;
2740         ut_params->cipher_xform.cipher.algo = cipher_algo;
2741         ut_params->cipher_xform.cipher.op = cipher_op;
2742         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2743         ut_params->cipher_xform.cipher.key.length = key_len;
2744         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2745         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2746
2747         debug_hexdump(stdout, "key:", key, key_len);
2748
2749         /* Create Crypto session*/
2750         ut_params->sess = rte_cryptodev_sym_session_create(
2751                         ts_params->session_mpool);
2752         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2753
2754         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2755                 ut_params->auth_xform.next = NULL;
2756                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2757                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2758                                 &ut_params->cipher_xform,
2759                                 ts_params->session_priv_mpool);
2760
2761         } else
2762                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2763                                 &ut_params->auth_xform,
2764                                 ts_params->session_priv_mpool);
2765
2766         if (status == -ENOTSUP)
2767                 return TEST_SKIPPED;
2768
2769         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2770
2771         return 0;
2772 }
2773
2774 static int
2775 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2776                 unsigned int auth_tag_len,
2777                 const uint8_t *iv, unsigned int iv_len,
2778                 unsigned int data_pad_len,
2779                 enum rte_crypto_auth_operation op,
2780                 unsigned int auth_len, unsigned int auth_offset)
2781 {
2782         struct crypto_testsuite_params *ts_params = &testsuite_params;
2783
2784         struct crypto_unittest_params *ut_params = &unittest_params;
2785
2786         /* Generate Crypto op data structure */
2787         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2788                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2789         TEST_ASSERT_NOT_NULL(ut_params->op,
2790                 "Failed to allocate pktmbuf offload");
2791
2792         /* Set crypto operation data parameters */
2793         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2794
2795         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2796
2797         /* set crypto operation source mbuf */
2798         sym_op->m_src = ut_params->ibuf;
2799
2800         /* iv */
2801         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2802                         iv, iv_len);
2803         /* digest */
2804         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2805                                         ut_params->ibuf, auth_tag_len);
2806
2807         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2808                                 "no room to append auth tag");
2809         ut_params->digest = sym_op->auth.digest.data;
2810         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2811                         ut_params->ibuf, data_pad_len);
2812         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2813                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2814         else
2815                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2816
2817         debug_hexdump(stdout, "digest:",
2818                 sym_op->auth.digest.data,
2819                 auth_tag_len);
2820
2821         sym_op->auth.data.length = auth_len;
2822         sym_op->auth.data.offset = auth_offset;
2823
2824         return 0;
2825 }
2826
2827 static int
2828 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2829         enum rte_crypto_auth_operation op)
2830 {
2831         struct crypto_testsuite_params *ts_params = &testsuite_params;
2832         struct crypto_unittest_params *ut_params = &unittest_params;
2833
2834         const uint8_t *auth_tag = tdata->digest.data;
2835         const unsigned int auth_tag_len = tdata->digest.len;
2836         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2837         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2838
2839         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2840         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2841         const uint8_t *auth_iv = tdata->auth_iv.data;
2842         const uint8_t auth_iv_len = tdata->auth_iv.len;
2843         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2844         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2845
2846         /* Generate Crypto op data structure */
2847         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2848                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2849         TEST_ASSERT_NOT_NULL(ut_params->op,
2850                         "Failed to allocate pktmbuf offload");
2851         /* Set crypto operation data parameters */
2852         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2853
2854         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2855
2856         /* set crypto operation source mbuf */
2857         sym_op->m_src = ut_params->ibuf;
2858
2859         /* digest */
2860         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2861                         ut_params->ibuf, auth_tag_len);
2862
2863         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2864                         "no room to append auth tag");
2865         ut_params->digest = sym_op->auth.digest.data;
2866         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2867                         ut_params->ibuf, data_pad_len);
2868         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2869                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2870         else
2871                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2872
2873         debug_hexdump(stdout, "digest:",
2874                 sym_op->auth.digest.data,
2875                 auth_tag_len);
2876
2877         /* Copy cipher and auth IVs at the end of the crypto operation */
2878         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2879                                                 IV_OFFSET);
2880         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2881         iv_ptr += cipher_iv_len;
2882         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2883
2884         sym_op->cipher.data.length = cipher_len;
2885         sym_op->cipher.data.offset = 0;
2886         sym_op->auth.data.length = auth_len;
2887         sym_op->auth.data.offset = 0;
2888
2889         return 0;
2890 }
2891
2892 static int
2893 create_zuc_cipher_hash_generate_operation(
2894                 const struct wireless_test_data *tdata)
2895 {
2896         return create_wireless_cipher_hash_operation(tdata,
2897                 RTE_CRYPTO_AUTH_OP_GENERATE);
2898 }
2899
2900 static int
2901 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2902                 const unsigned auth_tag_len,
2903                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2904                 unsigned data_pad_len,
2905                 enum rte_crypto_auth_operation op,
2906                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2907                 const unsigned cipher_len, const unsigned cipher_offset,
2908                 const unsigned auth_len, const unsigned auth_offset)
2909 {
2910         struct crypto_testsuite_params *ts_params = &testsuite_params;
2911         struct crypto_unittest_params *ut_params = &unittest_params;
2912
2913         enum rte_crypto_cipher_algorithm cipher_algo =
2914                         ut_params->cipher_xform.cipher.algo;
2915         enum rte_crypto_auth_algorithm auth_algo =
2916                         ut_params->auth_xform.auth.algo;
2917
2918         /* Generate Crypto op data structure */
2919         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2920                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2921         TEST_ASSERT_NOT_NULL(ut_params->op,
2922                         "Failed to allocate pktmbuf offload");
2923         /* Set crypto operation data parameters */
2924         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2925
2926         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2927
2928         /* set crypto operation source mbuf */
2929         sym_op->m_src = ut_params->ibuf;
2930
2931         /* digest */
2932         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2933                         ut_params->ibuf, auth_tag_len);
2934
2935         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2936                         "no room to append auth tag");
2937         ut_params->digest = sym_op->auth.digest.data;
2938
2939         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2940                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2941                                 ut_params->ibuf, data_pad_len);
2942         } else {
2943                 struct rte_mbuf *m = ut_params->ibuf;
2944                 unsigned int offset = data_pad_len;
2945
2946                 while (offset > m->data_len && m->next != NULL) {
2947                         offset -= m->data_len;
2948                         m = m->next;
2949                 }
2950                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2951                         m, offset);
2952         }
2953
2954         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2955                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2956         else
2957                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2958
2959         debug_hexdump(stdout, "digest:",
2960                 sym_op->auth.digest.data,
2961                 auth_tag_len);
2962
2963         /* Copy cipher and auth IVs at the end of the crypto operation */
2964         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2965                                                 IV_OFFSET);
2966         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2967         iv_ptr += cipher_iv_len;
2968         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2969
2970         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2971                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2972                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2973                 sym_op->cipher.data.length = cipher_len;
2974                 sym_op->cipher.data.offset = cipher_offset;
2975         } else {
2976                 sym_op->cipher.data.length = cipher_len >> 3;
2977                 sym_op->cipher.data.offset = cipher_offset >> 3;
2978         }
2979
2980         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2981                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2982                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2983                 sym_op->auth.data.length = auth_len;
2984                 sym_op->auth.data.offset = auth_offset;
2985         } else {
2986                 sym_op->auth.data.length = auth_len >> 3;
2987                 sym_op->auth.data.offset = auth_offset >> 3;
2988         }
2989
2990         return 0;
2991 }
2992
2993 static int
2994 create_wireless_algo_auth_cipher_operation(
2995                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2996                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2997                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2998                 unsigned int data_pad_len,
2999                 unsigned int cipher_len, unsigned int cipher_offset,
3000                 unsigned int auth_len, unsigned int auth_offset,
3001                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3002 {
3003         struct crypto_testsuite_params *ts_params = &testsuite_params;
3004         struct crypto_unittest_params *ut_params = &unittest_params;
3005
3006         enum rte_crypto_cipher_algorithm cipher_algo =
3007                         ut_params->cipher_xform.cipher.algo;
3008         enum rte_crypto_auth_algorithm auth_algo =
3009                         ut_params->auth_xform.auth.algo;
3010
3011         /* Generate Crypto op data structure */
3012         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3013                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3014         TEST_ASSERT_NOT_NULL(ut_params->op,
3015                         "Failed to allocate pktmbuf offload");
3016
3017         /* Set crypto operation data parameters */
3018         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3019
3020         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3021
3022         /* set crypto operation mbufs */
3023         sym_op->m_src = ut_params->ibuf;
3024         if (op_mode == OUT_OF_PLACE)
3025                 sym_op->m_dst = ut_params->obuf;
3026
3027         /* digest */
3028         if (!do_sgl) {
3029                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3030                         (op_mode == IN_PLACE ?
3031                                 ut_params->ibuf : ut_params->obuf),
3032                         uint8_t *, data_pad_len);
3033                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3034                         (op_mode == IN_PLACE ?
3035                                 ut_params->ibuf : ut_params->obuf),
3036                         data_pad_len);
3037                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3038         } else {
3039                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3040                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3041                                 sym_op->m_src : sym_op->m_dst);
3042                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3043                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3044                         sgl_buf = sgl_buf->next;
3045                 }
3046                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3047                                 uint8_t *, remaining_off);
3048                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3049                                 remaining_off);
3050                 memset(sym_op->auth.digest.data, 0, remaining_off);
3051                 while (sgl_buf->next != NULL) {
3052                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3053                                 0, rte_pktmbuf_data_len(sgl_buf));
3054                         sgl_buf = sgl_buf->next;
3055                 }
3056         }
3057
3058         /* Copy digest for the verification */
3059         if (verify)
3060                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3061
3062         /* Copy cipher and auth IVs at the end of the crypto operation */
3063         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3064                         ut_params->op, uint8_t *, IV_OFFSET);
3065
3066         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3067         iv_ptr += cipher_iv_len;
3068         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3069
3070         /* Only copy over the offset data needed from src to dst in OOP,
3071          * if the auth and cipher offsets are not aligned
3072          */
3073         if (op_mode == OUT_OF_PLACE) {
3074                 if (cipher_offset > auth_offset)
3075                         rte_memcpy(
3076                                 rte_pktmbuf_mtod_offset(
3077                                         sym_op->m_dst,
3078                                         uint8_t *, auth_offset >> 3),
3079                                 rte_pktmbuf_mtod_offset(
3080                                         sym_op->m_src,
3081                                         uint8_t *, auth_offset >> 3),
3082                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3083         }
3084
3085         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3086                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3087                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3088                 sym_op->cipher.data.length = cipher_len;
3089                 sym_op->cipher.data.offset = cipher_offset;
3090         } else {
3091                 sym_op->cipher.data.length = cipher_len >> 3;
3092                 sym_op->cipher.data.offset = cipher_offset >> 3;
3093         }
3094
3095         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3096                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3097                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3098                 sym_op->auth.data.length = auth_len;
3099                 sym_op->auth.data.offset = auth_offset;
3100         } else {
3101                 sym_op->auth.data.length = auth_len >> 3;
3102                 sym_op->auth.data.offset = auth_offset >> 3;
3103         }
3104
3105         return 0;
3106 }
3107
3108 static int
3109 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3110 {
3111         struct crypto_testsuite_params *ts_params = &testsuite_params;
3112         struct crypto_unittest_params *ut_params = &unittest_params;
3113
3114         int retval;
3115         unsigned plaintext_pad_len;
3116         unsigned plaintext_len;
3117         uint8_t *plaintext;
3118         struct rte_cryptodev_info dev_info;
3119
3120         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3121         uint64_t feat_flags = dev_info.feature_flags;
3122
3123         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3124                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3125                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3126                 return TEST_SKIPPED;
3127         }
3128
3129         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3130                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3131                 printf("Device doesn't support RAW data-path APIs.\n");
3132                 return TEST_SKIPPED;
3133         }
3134
3135         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3136                 return TEST_SKIPPED;
3137
3138         /* Verify the capabilities */
3139         struct rte_cryptodev_sym_capability_idx cap_idx;
3140         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3141         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3142         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3143                         &cap_idx) == NULL)
3144                 return TEST_SKIPPED;
3145
3146         /* Create SNOW 3G session */
3147         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3148                         tdata->key.data, tdata->key.len,
3149                         tdata->auth_iv.len, tdata->digest.len,
3150                         RTE_CRYPTO_AUTH_OP_GENERATE,
3151                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3152         if (retval < 0)
3153                 return retval;
3154
3155         /* alloc mbuf and set payload */
3156         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3157
3158         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3159         rte_pktmbuf_tailroom(ut_params->ibuf));
3160
3161         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3162         /* Append data which is padded to a multiple of */
3163         /* the algorithms block size */
3164         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3165         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3166                                 plaintext_pad_len);
3167         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3168
3169         /* Create SNOW 3G operation */
3170         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3171                         tdata->auth_iv.data, tdata->auth_iv.len,
3172                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3173                         tdata->validAuthLenInBits.len,
3174                         0);
3175         if (retval < 0)
3176                 return retval;
3177
3178         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3179                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3180                                 ut_params->op, 0, 1, 1, 0);
3181         else
3182                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3183                                 ut_params->op);
3184         ut_params->obuf = ut_params->op->sym->m_src;
3185         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3186         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3187                         + plaintext_pad_len;
3188
3189         /* Validate obuf */
3190         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3191         ut_params->digest,
3192         tdata->digest.data,
3193         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3194         "SNOW 3G Generated auth tag not as expected");
3195
3196         return 0;
3197 }
3198
3199 static int
3200 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3201 {
3202         struct crypto_testsuite_params *ts_params = &testsuite_params;
3203         struct crypto_unittest_params *ut_params = &unittest_params;
3204
3205         int retval;
3206         unsigned plaintext_pad_len;
3207         unsigned plaintext_len;
3208         uint8_t *plaintext;
3209         struct rte_cryptodev_info dev_info;
3210
3211         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3212         uint64_t feat_flags = dev_info.feature_flags;
3213
3214         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3215                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3216                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3217                 return TEST_SKIPPED;
3218         }
3219
3220         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3221                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3222                 printf("Device doesn't support RAW data-path APIs.\n");
3223                 return TEST_SKIPPED;
3224         }
3225
3226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3227                 return TEST_SKIPPED;
3228
3229         /* Verify the capabilities */
3230         struct rte_cryptodev_sym_capability_idx cap_idx;
3231         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3232         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3233         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3234                         &cap_idx) == NULL)
3235                 return TEST_SKIPPED;
3236
3237         /* Create SNOW 3G session */
3238         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3239                                 tdata->key.data, tdata->key.len,
3240                                 tdata->auth_iv.len, tdata->digest.len,
3241                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3242                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3243         if (retval < 0)
3244                 return retval;
3245         /* alloc mbuf and set payload */
3246         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3247
3248         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3249         rte_pktmbuf_tailroom(ut_params->ibuf));
3250
3251         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3252         /* Append data which is padded to a multiple of */
3253         /* the algorithms block size */
3254         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3255         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3256                                 plaintext_pad_len);
3257         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3258
3259         /* Create SNOW 3G operation */
3260         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3261                         tdata->digest.len,
3262                         tdata->auth_iv.data, tdata->auth_iv.len,
3263                         plaintext_pad_len,
3264                         RTE_CRYPTO_AUTH_OP_VERIFY,
3265                         tdata->validAuthLenInBits.len,
3266                         0);
3267         if (retval < 0)
3268                 return retval;
3269
3270         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3271                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3272                                 ut_params->op, 0, 1, 1, 0);
3273         else
3274                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3275                                 ut_params->op);
3276         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3277         ut_params->obuf = ut_params->op->sym->m_src;
3278         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3279                                 + plaintext_pad_len;
3280
3281         /* Validate obuf */
3282         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3283                 return 0;
3284         else
3285                 return -1;
3286
3287         return 0;
3288 }
3289
3290 static int
3291 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3292 {
3293         struct crypto_testsuite_params *ts_params = &testsuite_params;
3294         struct crypto_unittest_params *ut_params = &unittest_params;
3295
3296         int retval;
3297         unsigned plaintext_pad_len;
3298         unsigned plaintext_len;
3299         uint8_t *plaintext;
3300         struct rte_cryptodev_info dev_info;
3301
3302         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3303         uint64_t feat_flags = dev_info.feature_flags;
3304
3305         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3306                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3307                 printf("Device doesn't support RAW data-path APIs.\n");
3308                 return TEST_SKIPPED;
3309         }
3310
3311         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3312                 return TEST_SKIPPED;
3313
3314         /* Verify the capabilities */
3315         struct rte_cryptodev_sym_capability_idx cap_idx;
3316         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3317         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3318         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3319                         &cap_idx) == NULL)
3320                 return TEST_SKIPPED;
3321
3322         /* Create KASUMI session */
3323         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3324                         tdata->key.data, tdata->key.len,
3325                         0, tdata->digest.len,
3326                         RTE_CRYPTO_AUTH_OP_GENERATE,
3327                         RTE_CRYPTO_AUTH_KASUMI_F9);
3328         if (retval < 0)
3329                 return retval;
3330
3331         /* alloc mbuf and set payload */
3332         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3333
3334         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3335         rte_pktmbuf_tailroom(ut_params->ibuf));
3336
3337         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3338         /* Append data which is padded to a multiple of */
3339         /* the algorithms block size */
3340         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3341         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3342                                 plaintext_pad_len);
3343         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3344
3345         /* Create KASUMI operation */
3346         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3347                         NULL, 0,
3348                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3349                         tdata->plaintext.len,
3350                         0);
3351         if (retval < 0)
3352                 return retval;
3353
3354         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3355                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3356                         ut_params->op);
3357         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3358                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3359                                 ut_params->op, 0, 1, 1, 0);
3360         else
3361                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3362                         ut_params->op);
3363
3364         ut_params->obuf = ut_params->op->sym->m_src;
3365         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3366         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3367                         + plaintext_pad_len;
3368
3369         /* Validate obuf */
3370         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3371         ut_params->digest,
3372         tdata->digest.data,
3373         DIGEST_BYTE_LENGTH_KASUMI_F9,
3374         "KASUMI Generated auth tag not as expected");
3375
3376         return 0;
3377 }
3378
3379 static int
3380 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3381 {
3382         struct crypto_testsuite_params *ts_params = &testsuite_params;
3383         struct crypto_unittest_params *ut_params = &unittest_params;
3384
3385         int retval;
3386         unsigned plaintext_pad_len;
3387         unsigned plaintext_len;
3388         uint8_t *plaintext;
3389         struct rte_cryptodev_info dev_info;
3390
3391         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3392         uint64_t feat_flags = dev_info.feature_flags;
3393
3394         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3395                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3396                 printf("Device doesn't support RAW data-path APIs.\n");
3397                 return TEST_SKIPPED;
3398         }
3399
3400         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3401                 return TEST_SKIPPED;
3402
3403         /* Verify the capabilities */
3404         struct rte_cryptodev_sym_capability_idx cap_idx;
3405         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3406         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3407         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3408                         &cap_idx) == NULL)
3409                 return TEST_SKIPPED;
3410
3411         /* Create KASUMI session */
3412         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3413                                 tdata->key.data, tdata->key.len,
3414                                 0, tdata->digest.len,
3415                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3416                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3417         if (retval < 0)
3418                 return retval;
3419         /* alloc mbuf and set payload */
3420         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3421
3422         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3423         rte_pktmbuf_tailroom(ut_params->ibuf));
3424
3425         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3426         /* Append data which is padded to a multiple */
3427         /* of the algorithms block size */
3428         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3429         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3430                                 plaintext_pad_len);
3431         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3432
3433         /* Create KASUMI operation */
3434         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3435                         tdata->digest.len,
3436                         NULL, 0,
3437                         plaintext_pad_len,
3438                         RTE_CRYPTO_AUTH_OP_VERIFY,
3439                         tdata->plaintext.len,
3440                         0);
3441         if (retval < 0)
3442                 return retval;
3443
3444         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3445                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3446                                 ut_params->op, 0, 1, 1, 0);
3447         else
3448                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3449                                 ut_params->op);
3450         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3451         ut_params->obuf = ut_params->op->sym->m_src;
3452         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3453                                 + plaintext_pad_len;
3454
3455         /* Validate obuf */
3456         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3457                 return 0;
3458         else
3459                 return -1;
3460
3461         return 0;
3462 }
3463
3464 static int
3465 test_snow3g_hash_generate_test_case_1(void)
3466 {
3467         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3468 }
3469
3470 static int
3471 test_snow3g_hash_generate_test_case_2(void)
3472 {
3473         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3474 }
3475
3476 static int
3477 test_snow3g_hash_generate_test_case_3(void)
3478 {
3479         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3480 }
3481
3482 static int
3483 test_snow3g_hash_generate_test_case_4(void)
3484 {
3485         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3486 }
3487
3488 static int
3489 test_snow3g_hash_generate_test_case_5(void)
3490 {
3491         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3492 }
3493
3494 static int
3495 test_snow3g_hash_generate_test_case_6(void)
3496 {
3497         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3498 }
3499
3500 static int
3501 test_snow3g_hash_verify_test_case_1(void)
3502 {
3503         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3504
3505 }
3506
3507 static int
3508 test_snow3g_hash_verify_test_case_2(void)
3509 {
3510         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3511 }
3512
3513 static int
3514 test_snow3g_hash_verify_test_case_3(void)
3515 {
3516         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3517 }
3518
3519 static int
3520 test_snow3g_hash_verify_test_case_4(void)
3521 {
3522         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3523 }
3524
3525 static int
3526 test_snow3g_hash_verify_test_case_5(void)
3527 {
3528         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3529 }
3530
3531 static int
3532 test_snow3g_hash_verify_test_case_6(void)
3533 {
3534         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3535 }
3536
3537 static int
3538 test_kasumi_hash_generate_test_case_1(void)
3539 {
3540         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3541 }
3542
3543 static int
3544 test_kasumi_hash_generate_test_case_2(void)
3545 {
3546         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3547 }
3548
3549 static int
3550 test_kasumi_hash_generate_test_case_3(void)
3551 {
3552         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3553 }
3554
3555 static int
3556 test_kasumi_hash_generate_test_case_4(void)
3557 {
3558         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3559 }
3560
3561 static int
3562 test_kasumi_hash_generate_test_case_5(void)
3563 {
3564         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3565 }
3566
3567 static int
3568 test_kasumi_hash_generate_test_case_6(void)
3569 {
3570         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3571 }
3572
3573 static int
3574 test_kasumi_hash_verify_test_case_1(void)
3575 {
3576         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3577 }
3578
3579 static int
3580 test_kasumi_hash_verify_test_case_2(void)
3581 {
3582         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3583 }
3584
3585 static int
3586 test_kasumi_hash_verify_test_case_3(void)
3587 {
3588         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3589 }
3590
3591 static int
3592 test_kasumi_hash_verify_test_case_4(void)
3593 {
3594         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3595 }
3596
3597 static int
3598 test_kasumi_hash_verify_test_case_5(void)
3599 {
3600         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3601 }
3602
3603 static int
3604 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3605 {
3606         struct crypto_testsuite_params *ts_params = &testsuite_params;
3607         struct crypto_unittest_params *ut_params = &unittest_params;
3608
3609         int retval;
3610         uint8_t *plaintext, *ciphertext;
3611         unsigned plaintext_pad_len;
3612         unsigned plaintext_len;
3613         struct rte_cryptodev_info dev_info;
3614
3615         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3616         uint64_t feat_flags = dev_info.feature_flags;
3617
3618         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3619                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3620                 printf("Device doesn't support RAW data-path APIs.\n");
3621                 return TEST_SKIPPED;
3622         }
3623
3624         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3625                 return TEST_SKIPPED;
3626
3627         /* Verify the capabilities */
3628         struct rte_cryptodev_sym_capability_idx cap_idx;
3629         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3630         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3631         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3632                         &cap_idx) == NULL)
3633                 return TEST_SKIPPED;
3634
3635         /* Create KASUMI session */
3636         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3637                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3638                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3639                                         tdata->key.data, tdata->key.len,
3640                                         tdata->cipher_iv.len);
3641         if (retval < 0)
3642                 return retval;
3643
3644         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3645
3646         /* Clear mbuf payload */
3647         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3648                rte_pktmbuf_tailroom(ut_params->ibuf));
3649
3650         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3651         /* Append data which is padded to a multiple */
3652         /* of the algorithms block size */
3653         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3654         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3655                                 plaintext_pad_len);
3656         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3657
3658         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3659
3660         /* Create KASUMI operation */
3661         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3662                                 tdata->cipher_iv.len,
3663                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3664                                 tdata->validCipherOffsetInBits.len);
3665         if (retval < 0)
3666                 return retval;
3667
3668         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3669                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3670                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3671         else
3672                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3673                                 ut_params->op);
3674         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3675
3676         ut_params->obuf = ut_params->op->sym->m_dst;
3677         if (ut_params->obuf)
3678                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3679         else
3680                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3681
3682         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3683
3684         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3685                                 (tdata->validCipherOffsetInBits.len >> 3);
3686         /* Validate obuf */
3687         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3688                 ciphertext,
3689                 reference_ciphertext,
3690                 tdata->validCipherLenInBits.len,
3691                 "KASUMI Ciphertext data not as expected");
3692         return 0;
3693 }
3694
3695 static int
3696 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3697 {
3698         struct crypto_testsuite_params *ts_params = &testsuite_params;
3699         struct crypto_unittest_params *ut_params = &unittest_params;
3700
3701         int retval;
3702
3703         unsigned int plaintext_pad_len;
3704         unsigned int plaintext_len;
3705
3706         uint8_t buffer[10000];
3707         const uint8_t *ciphertext;
3708
3709         struct rte_cryptodev_info dev_info;
3710
3711         /* Verify the capabilities */
3712         struct rte_cryptodev_sym_capability_idx cap_idx;
3713         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3714         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3715         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3716                         &cap_idx) == NULL)
3717                 return TEST_SKIPPED;
3718
3719         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3720
3721         uint64_t feat_flags = dev_info.feature_flags;
3722
3723         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3724                 printf("Device doesn't support in-place scatter-gather. "
3725                                 "Test Skipped.\n");
3726                 return TEST_SKIPPED;
3727         }
3728
3729         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3730                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3731                 printf("Device doesn't support RAW data-path APIs.\n");
3732                 return TEST_SKIPPED;
3733         }
3734
3735         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3736                 return TEST_SKIPPED;
3737
3738         /* Create KASUMI session */
3739         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3740                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3741                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3742                                         tdata->key.data, tdata->key.len,
3743                                         tdata->cipher_iv.len);
3744         if (retval < 0)
3745                 return retval;
3746
3747         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3748
3749
3750         /* Append data which is padded to a multiple */
3751         /* of the algorithms block size */
3752         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3753
3754         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3755                         plaintext_pad_len, 10, 0);
3756
3757         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3758
3759         /* Create KASUMI operation */
3760         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3761                                 tdata->cipher_iv.len,
3762                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3763                                 tdata->validCipherOffsetInBits.len);
3764         if (retval < 0)
3765                 return retval;
3766
3767         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3768                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3769                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3770         else
3771                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3772                                                 ut_params->op);
3773         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3774
3775         ut_params->obuf = ut_params->op->sym->m_dst;
3776
3777         if (ut_params->obuf)
3778                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3779                                 plaintext_len, buffer);
3780         else
3781                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3782                                 tdata->validCipherOffsetInBits.len >> 3,
3783                                 plaintext_len, buffer);
3784
3785         /* Validate obuf */
3786         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3787
3788         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3789                                 (tdata->validCipherOffsetInBits.len >> 3);
3790         /* Validate obuf */
3791         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3792                 ciphertext,
3793                 reference_ciphertext,
3794                 tdata->validCipherLenInBits.len,
3795                 "KASUMI Ciphertext data not as expected");
3796         return 0;
3797 }
3798
3799 static int
3800 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3801 {
3802         struct crypto_testsuite_params *ts_params = &testsuite_params;
3803         struct crypto_unittest_params *ut_params = &unittest_params;
3804
3805         int retval;
3806         uint8_t *plaintext, *ciphertext;
3807         unsigned plaintext_pad_len;
3808         unsigned plaintext_len;
3809
3810         /* Verify the capabilities */
3811         struct rte_cryptodev_sym_capability_idx cap_idx;
3812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3813         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3814         /* Data-path service does not support OOP */
3815         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3816                         &cap_idx) == NULL)
3817                 return TEST_SKIPPED;
3818
3819         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3820                 return TEST_SKIPPED;
3821
3822         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3823                 return TEST_SKIPPED;
3824
3825         /* Create KASUMI session */
3826         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3827                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3828                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3829                                         tdata->key.data, tdata->key.len,
3830                                         tdata->cipher_iv.len);
3831         if (retval < 0)
3832                 return retval;
3833
3834         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3835         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3836
3837         /* Clear mbuf payload */
3838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3839                rte_pktmbuf_tailroom(ut_params->ibuf));
3840
3841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3842         /* Append data which is padded to a multiple */
3843         /* of the algorithms block size */
3844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3846                                 plaintext_pad_len);
3847         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3848         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3849
3850         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3851
3852         /* Create KASUMI operation */
3853         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3854                                 tdata->cipher_iv.len,
3855                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3856                                 tdata->validCipherOffsetInBits.len);
3857         if (retval < 0)
3858                 return retval;
3859
3860         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3861                                                 ut_params->op);
3862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3863
3864         ut_params->obuf = ut_params->op->sym->m_dst;
3865         if (ut_params->obuf)
3866                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3867         else
3868                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3869
3870         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3871
3872         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3873                                 (tdata->validCipherOffsetInBits.len >> 3);
3874         /* Validate obuf */
3875         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3876                 ciphertext,
3877                 reference_ciphertext,
3878                 tdata->validCipherLenInBits.len,
3879                 "KASUMI Ciphertext data not as expected");
3880         return 0;
3881 }
3882
3883 static int
3884 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3885 {
3886         struct crypto_testsuite_params *ts_params = &testsuite_params;
3887         struct crypto_unittest_params *ut_params = &unittest_params;
3888
3889         int retval;
3890         unsigned int plaintext_pad_len;
3891         unsigned int plaintext_len;
3892
3893         const uint8_t *ciphertext;
3894         uint8_t buffer[2048];
3895
3896         struct rte_cryptodev_info dev_info;
3897
3898         /* Verify the capabilities */
3899         struct rte_cryptodev_sym_capability_idx cap_idx;
3900         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3901         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3902         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3903                         &cap_idx) == NULL)
3904                 return TEST_SKIPPED;
3905
3906         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3907                 return TEST_SKIPPED;
3908
3909         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3910                 return TEST_SKIPPED;
3911
3912         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3913
3914         uint64_t feat_flags = dev_info.feature_flags;
3915         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3916                 printf("Device doesn't support out-of-place scatter-gather "
3917                                 "in both input and output mbufs. "
3918                                 "Test Skipped.\n");
3919                 return TEST_SKIPPED;
3920         }
3921
3922         /* Create KASUMI session */
3923         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3924                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3925                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3926                                         tdata->key.data, tdata->key.len,
3927                                         tdata->cipher_iv.len);
3928         if (retval < 0)
3929                 return retval;
3930
3931         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3932         /* Append data which is padded to a multiple */
3933         /* of the algorithms block size */
3934         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3935
3936         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3937                         plaintext_pad_len, 10, 0);
3938         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3939                         plaintext_pad_len, 3, 0);
3940
3941         /* Append data which is padded to a multiple */
3942         /* of the algorithms block size */
3943         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3944
3945         /* Create KASUMI operation */
3946         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3947                                 tdata->cipher_iv.len,
3948                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3949                                 tdata->validCipherOffsetInBits.len);
3950         if (retval < 0)
3951                 return retval;
3952
3953         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3954                                                 ut_params->op);
3955         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3956
3957         ut_params->obuf = ut_params->op->sym->m_dst;
3958         if (ut_params->obuf)
3959                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3960                                 plaintext_pad_len, buffer);
3961         else
3962                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3963                                 tdata->validCipherOffsetInBits.len >> 3,
3964                                 plaintext_pad_len, buffer);
3965
3966         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3967                                 (tdata->validCipherOffsetInBits.len >> 3);
3968         /* Validate obuf */
3969         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3970                 ciphertext,
3971                 reference_ciphertext,
3972                 tdata->validCipherLenInBits.len,
3973                 "KASUMI Ciphertext data not as expected");
3974         return 0;
3975 }
3976
3977
3978 static int
3979 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3980 {
3981         struct crypto_testsuite_params *ts_params = &testsuite_params;
3982         struct crypto_unittest_params *ut_params = &unittest_params;
3983
3984         int retval;
3985         uint8_t *ciphertext, *plaintext;
3986         unsigned ciphertext_pad_len;
3987         unsigned ciphertext_len;
3988
3989         /* Verify the capabilities */
3990         struct rte_cryptodev_sym_capability_idx cap_idx;
3991         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3992         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3993         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3994                         &cap_idx) == NULL)
3995                 return TEST_SKIPPED;
3996
3997         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3998                 return TEST_SKIPPED;
3999
4000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4001                 return TEST_SKIPPED;
4002
4003         /* Create KASUMI session */
4004         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4005                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4006                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4007                                         tdata->key.data, tdata->key.len,
4008                                         tdata->cipher_iv.len);
4009         if (retval < 0)
4010                 return retval;
4011
4012         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4013         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4014
4015         /* Clear mbuf payload */
4016         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4017                rte_pktmbuf_tailroom(ut_params->ibuf));
4018
4019         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4020         /* Append data which is padded to a multiple */
4021         /* of the algorithms block size */
4022         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4023         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4024                                 ciphertext_pad_len);
4025         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4026         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4027
4028         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4029
4030         /* Create KASUMI operation */
4031         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4032                                 tdata->cipher_iv.len,
4033                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4034                                 tdata->validCipherOffsetInBits.len);
4035         if (retval < 0)
4036                 return retval;
4037
4038         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4039                                                 ut_params->op);
4040         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4041
4042         ut_params->obuf = ut_params->op->sym->m_dst;
4043         if (ut_params->obuf)
4044                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4045         else
4046                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4047
4048         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4049
4050         const uint8_t *reference_plaintext = tdata->plaintext.data +
4051                                 (tdata->validCipherOffsetInBits.len >> 3);
4052         /* Validate obuf */
4053         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4054                 plaintext,
4055                 reference_plaintext,
4056                 tdata->validCipherLenInBits.len,
4057                 "KASUMI Plaintext data not as expected");
4058         return 0;
4059 }
4060
4061 static int
4062 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4063 {
4064         struct crypto_testsuite_params *ts_params = &testsuite_params;
4065         struct crypto_unittest_params *ut_params = &unittest_params;
4066
4067         int retval;
4068         uint8_t *ciphertext, *plaintext;
4069         unsigned ciphertext_pad_len;
4070         unsigned ciphertext_len;
4071         struct rte_cryptodev_info dev_info;
4072
4073         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4074         uint64_t feat_flags = dev_info.feature_flags;
4075
4076         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4077                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4078                 printf("Device doesn't support RAW data-path APIs.\n");
4079                 return TEST_SKIPPED;
4080         }
4081
4082         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4083                 return TEST_SKIPPED;
4084
4085         /* Verify the capabilities */
4086         struct rte_cryptodev_sym_capability_idx cap_idx;
4087         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4088         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4089         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4090                         &cap_idx) == NULL)
4091                 return TEST_SKIPPED;
4092
4093         /* Create KASUMI session */
4094         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4095                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4096                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4097                                         tdata->key.data, tdata->key.len,
4098                                         tdata->cipher_iv.len);
4099         if (retval < 0)
4100                 return retval;
4101
4102         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4103
4104         /* Clear mbuf payload */
4105         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4106                rte_pktmbuf_tailroom(ut_params->ibuf));
4107
4108         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4109         /* Append data which is padded to a multiple */
4110         /* of the algorithms block size */
4111         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4112         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4113                                 ciphertext_pad_len);
4114         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4115
4116         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4117
4118         /* Create KASUMI operation */
4119         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4120                         tdata->cipher_iv.len,
4121                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4122                         tdata->validCipherOffsetInBits.len);
4123         if (retval < 0)
4124                 return retval;
4125
4126         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4127                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4128                                 ut_params->op, 1, 0, 1, 0);
4129         else
4130                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4131                                                 ut_params->op);
4132         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4133
4134         ut_params->obuf = ut_params->op->sym->m_dst;
4135         if (ut_params->obuf)
4136                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4137         else
4138                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4139
4140         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4141
4142         const uint8_t *reference_plaintext = tdata->plaintext.data +
4143                                 (tdata->validCipherOffsetInBits.len >> 3);
4144         /* Validate obuf */
4145         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4146                 plaintext,
4147                 reference_plaintext,
4148                 tdata->validCipherLenInBits.len,
4149                 "KASUMI Plaintext data not as expected");
4150         return 0;
4151 }
4152
4153 static int
4154 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4155 {
4156         struct crypto_testsuite_params *ts_params = &testsuite_params;
4157         struct crypto_unittest_params *ut_params = &unittest_params;
4158
4159         int retval;
4160         uint8_t *plaintext, *ciphertext;
4161         unsigned plaintext_pad_len;
4162         unsigned plaintext_len;
4163         struct rte_cryptodev_info dev_info;
4164
4165         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4166         uint64_t feat_flags = dev_info.feature_flags;
4167
4168         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4169                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4170                 printf("Device doesn't support RAW data-path APIs.\n");
4171                 return TEST_SKIPPED;
4172         }
4173
4174         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4175                 return TEST_SKIPPED;
4176
4177         /* Verify the capabilities */
4178         struct rte_cryptodev_sym_capability_idx cap_idx;
4179         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4180         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4181         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4182                         &cap_idx) == NULL)
4183                 return TEST_SKIPPED;
4184
4185         /* Create SNOW 3G session */
4186         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4187                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4188                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4189                                         tdata->key.data, tdata->key.len,
4190                                         tdata->cipher_iv.len);
4191         if (retval < 0)
4192                 return retval;
4193
4194         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4195
4196         /* Clear mbuf payload */
4197         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4198                rte_pktmbuf_tailroom(ut_params->ibuf));
4199
4200         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4201         /* Append data which is padded to a multiple of */
4202         /* the algorithms block size */
4203         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4204         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4205                                 plaintext_pad_len);
4206         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4207
4208         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4209
4210         /* Create SNOW 3G operation */
4211         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4212                                         tdata->cipher_iv.len,
4213                                         tdata->validCipherLenInBits.len,
4214                                         0);
4215         if (retval < 0)
4216                 return retval;
4217
4218         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4219                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4220                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4221         else
4222                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4223                                                 ut_params->op);
4224         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4225
4226         ut_params->obuf = ut_params->op->sym->m_dst;
4227         if (ut_params->obuf)
4228                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4229         else
4230                 ciphertext = plaintext;
4231
4232         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4233
4234         /* Validate obuf */
4235         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4236                 ciphertext,
4237                 tdata->ciphertext.data,
4238                 tdata->validDataLenInBits.len,
4239                 "SNOW 3G Ciphertext data not as expected");
4240         return 0;
4241 }
4242
4243
4244 static int
4245 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4246 {
4247         struct crypto_testsuite_params *ts_params = &testsuite_params;
4248         struct crypto_unittest_params *ut_params = &unittest_params;
4249         uint8_t *plaintext, *ciphertext;
4250
4251         int retval;
4252         unsigned plaintext_pad_len;
4253         unsigned plaintext_len;
4254         struct rte_cryptodev_info dev_info;
4255
4256         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4257         uint64_t feat_flags = dev_info.feature_flags;
4258
4259         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4260                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4261                 printf("Device does not support RAW data-path APIs.\n");
4262                 return -ENOTSUP;
4263         }
4264
4265         /* Verify the capabilities */
4266         struct rte_cryptodev_sym_capability_idx cap_idx;
4267         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4268         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4269         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4270                         &cap_idx) == NULL)
4271                 return TEST_SKIPPED;
4272
4273         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4274                 return TEST_SKIPPED;
4275
4276         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4277                 return TEST_SKIPPED;
4278
4279         /* Create SNOW 3G session */
4280         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4281                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4282                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4283                                         tdata->key.data, tdata->key.len,
4284                                         tdata->cipher_iv.len);
4285         if (retval < 0)
4286                 return retval;
4287
4288         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4289         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4290
4291         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4292                         "Failed to allocate input buffer in mempool");
4293         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4294                         "Failed to allocate output buffer in mempool");
4295
4296         /* Clear mbuf payload */
4297         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4298                rte_pktmbuf_tailroom(ut_params->ibuf));
4299
4300         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4301         /* Append data which is padded to a multiple of */
4302         /* the algorithms block size */
4303         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4304         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4305                                 plaintext_pad_len);
4306         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4307         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4308
4309         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4310
4311         /* Create SNOW 3G operation */
4312         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4313                                         tdata->cipher_iv.len,
4314                                         tdata->validCipherLenInBits.len,
4315                                         0);
4316         if (retval < 0)
4317                 return retval;
4318
4319         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4320                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4321                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4322         else
4323                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4324                                                 ut_params->op);
4325         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4326
4327         ut_params->obuf = ut_params->op->sym->m_dst;
4328         if (ut_params->obuf)
4329                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4330         else
4331                 ciphertext = plaintext;
4332
4333         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4334
4335         /* Validate obuf */
4336         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4337                 ciphertext,
4338                 tdata->ciphertext.data,
4339                 tdata->validDataLenInBits.len,
4340                 "SNOW 3G Ciphertext data not as expected");
4341         return 0;
4342 }
4343
4344 static int
4345 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4346 {
4347         struct crypto_testsuite_params *ts_params = &testsuite_params;
4348         struct crypto_unittest_params *ut_params = &unittest_params;
4349
4350         int retval;
4351         unsigned int plaintext_pad_len;
4352         unsigned int plaintext_len;
4353         uint8_t buffer[10000];
4354         const uint8_t *ciphertext;
4355
4356         struct rte_cryptodev_info dev_info;
4357
4358         /* Verify the capabilities */
4359         struct rte_cryptodev_sym_capability_idx cap_idx;
4360         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4361         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4362         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4363                         &cap_idx) == NULL)
4364                 return TEST_SKIPPED;
4365
4366         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4367                 return TEST_SKIPPED;
4368
4369         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4370                 return TEST_SKIPPED;
4371
4372         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4373
4374         uint64_t feat_flags = dev_info.feature_flags;
4375
4376         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4377                 printf("Device doesn't support out-of-place scatter-gather "
4378                                 "in both input and output mbufs. "
4379                                 "Test Skipped.\n");
4380                 return TEST_SKIPPED;
4381         }
4382
4383         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4384                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4385                 printf("Device does not support RAW data-path APIs.\n");
4386                 return -ENOTSUP;
4387         }
4388
4389         /* Create SNOW 3G session */
4390         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4391                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4392                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4393                                         tdata->key.data, tdata->key.len,
4394                                         tdata->cipher_iv.len);
4395         if (retval < 0)
4396                 return retval;
4397
4398         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4399         /* Append data which is padded to a multiple of */
4400         /* the algorithms block size */
4401         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4402
4403         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4404                         plaintext_pad_len, 10, 0);
4405         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4406                         plaintext_pad_len, 3, 0);
4407
4408         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4409                         "Failed to allocate input buffer in mempool");
4410         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4411                         "Failed to allocate output buffer in mempool");
4412
4413         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4414
4415         /* Create SNOW 3G operation */
4416         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4417                                         tdata->cipher_iv.len,
4418                                         tdata->validCipherLenInBits.len,
4419                                         0);
4420         if (retval < 0)
4421                 return retval;
4422
4423         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4424                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4425                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4426         else
4427                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4428                                                 ut_params->op);
4429         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4430
4431         ut_params->obuf = ut_params->op->sym->m_dst;
4432         if (ut_params->obuf)
4433                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4434                                 plaintext_len, buffer);
4435         else
4436                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4437                                 plaintext_len, buffer);
4438
4439         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4440
4441         /* Validate obuf */
4442         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4443                 ciphertext,
4444                 tdata->ciphertext.data,
4445                 tdata->validDataLenInBits.len,
4446                 "SNOW 3G Ciphertext data not as expected");
4447
4448         return 0;
4449 }
4450
4451 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4452 static void
4453 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4454 {
4455         uint8_t curr_byte, prev_byte;
4456         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4457         uint8_t lower_byte_mask = (1 << offset) - 1;
4458         unsigned i;
4459
4460         prev_byte = buffer[0];
4461         buffer[0] >>= offset;
4462
4463         for (i = 1; i < length_in_bytes; i++) {
4464                 curr_byte = buffer[i];
4465                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4466                                 (curr_byte >> offset);
4467                 prev_byte = curr_byte;
4468         }
4469 }
4470
4471 static int
4472 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4473 {
4474         struct crypto_testsuite_params *ts_params = &testsuite_params;
4475         struct crypto_unittest_params *ut_params = &unittest_params;
4476         uint8_t *plaintext, *ciphertext;
4477         int retval;
4478         uint32_t plaintext_len;
4479         uint32_t plaintext_pad_len;
4480         uint8_t extra_offset = 4;
4481         uint8_t *expected_ciphertext_shifted;
4482         struct rte_cryptodev_info dev_info;
4483
4484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4485         uint64_t feat_flags = dev_info.feature_flags;
4486
4487         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4488                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4489                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4490                 return TEST_SKIPPED;
4491         }
4492
4493         /* Verify the capabilities */
4494         struct rte_cryptodev_sym_capability_idx cap_idx;
4495         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4496         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4497         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4498                         &cap_idx) == NULL)
4499                 return TEST_SKIPPED;
4500
4501         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4502                 return TEST_SKIPPED;
4503
4504         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4505                 return TEST_SKIPPED;
4506
4507         /* Create SNOW 3G session */
4508         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4509                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4510                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4511                                         tdata->key.data, tdata->key.len,
4512                                         tdata->cipher_iv.len);
4513         if (retval < 0)
4514                 return retval;
4515
4516         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4517         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4518
4519         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4520                         "Failed to allocate input buffer in mempool");
4521         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4522                         "Failed to allocate output buffer in mempool");
4523
4524         /* Clear mbuf payload */
4525         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4526                rte_pktmbuf_tailroom(ut_params->ibuf));
4527
4528         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4529         /*
4530          * Append data which is padded to a
4531          * multiple of the algorithms block size
4532          */
4533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4534
4535         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4536                                                 plaintext_pad_len);
4537
4538         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4539
4540         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4541         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4542
4543 #ifdef RTE_APP_TEST_DEBUG
4544         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4545 #endif
4546         /* Create SNOW 3G operation */
4547         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4548                                         tdata->cipher_iv.len,
4549                                         tdata->validCipherLenInBits.len,
4550                                         extra_offset);
4551         if (retval < 0)
4552                 return retval;
4553
4554         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4555                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4556                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4557         else
4558                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4559                                                 ut_params->op);
4560         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4561
4562         ut_params->obuf = ut_params->op->sym->m_dst;
4563         if (ut_params->obuf)
4564                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4565         else
4566                 ciphertext = plaintext;
4567
4568 #ifdef RTE_APP_TEST_DEBUG
4569         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4570 #endif
4571
4572         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4573
4574         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4575                         "failed to reserve memory for ciphertext shifted\n");
4576
4577         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4578                         ceil_byte_length(tdata->ciphertext.len));
4579         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4580                         extra_offset);
4581         /* Validate obuf */
4582         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4583                 ciphertext,
4584                 expected_ciphertext_shifted,
4585                 tdata->validDataLenInBits.len,
4586                 extra_offset,
4587                 "SNOW 3G Ciphertext data not as expected");
4588         return 0;
4589 }
4590
4591 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4592 {
4593         struct crypto_testsuite_params *ts_params = &testsuite_params;
4594         struct crypto_unittest_params *ut_params = &unittest_params;
4595
4596         int retval;
4597
4598         uint8_t *plaintext, *ciphertext;
4599         unsigned ciphertext_pad_len;
4600         unsigned ciphertext_len;
4601         struct rte_cryptodev_info dev_info;
4602
4603         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4604         uint64_t feat_flags = dev_info.feature_flags;
4605
4606         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4607                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4608                 printf("Device doesn't support RAW data-path APIs.\n");
4609                 return TEST_SKIPPED;
4610         }
4611
4612         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4613                 return TEST_SKIPPED;
4614
4615         /* Verify the capabilities */
4616         struct rte_cryptodev_sym_capability_idx cap_idx;
4617         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4618         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4619         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4620                         &cap_idx) == NULL)
4621                 return TEST_SKIPPED;
4622
4623         /* Create SNOW 3G session */
4624         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4625                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4626                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4627                                         tdata->key.data, tdata->key.len,
4628                                         tdata->cipher_iv.len);
4629         if (retval < 0)
4630                 return retval;
4631
4632         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4633
4634         /* Clear mbuf payload */
4635         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4636                rte_pktmbuf_tailroom(ut_params->ibuf));
4637
4638         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4639         /* Append data which is padded to a multiple of */
4640         /* the algorithms block size */
4641         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4642         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4643                                 ciphertext_pad_len);
4644         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4645
4646         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4647
4648         /* Create SNOW 3G operation */
4649         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4650                                         tdata->cipher_iv.len,
4651                                         tdata->validCipherLenInBits.len,
4652                                         tdata->cipher.offset_bits);
4653         if (retval < 0)
4654                 return retval;
4655
4656         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4657                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4658                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4659         else
4660                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4661                                                 ut_params->op);
4662         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4663         ut_params->obuf = ut_params->op->sym->m_dst;
4664         if (ut_params->obuf)
4665                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4666         else
4667                 plaintext = ciphertext;
4668
4669         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4670
4671         /* Validate obuf */
4672         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4673                                 tdata->plaintext.data,
4674                                 tdata->validDataLenInBits.len,
4675                                 "SNOW 3G Plaintext data not as expected");
4676         return 0;
4677 }
4678
4679 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4680 {
4681         struct crypto_testsuite_params *ts_params = &testsuite_params;
4682         struct crypto_unittest_params *ut_params = &unittest_params;
4683
4684         int retval;
4685
4686         uint8_t *plaintext, *ciphertext;
4687         unsigned ciphertext_pad_len;
4688         unsigned ciphertext_len;
4689         struct rte_cryptodev_info dev_info;
4690
4691         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4692         uint64_t feat_flags = dev_info.feature_flags;
4693
4694         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4695                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4696                 printf("Device does not support RAW data-path APIs.\n");
4697                 return -ENOTSUP;
4698         }
4699         /* Verify the capabilities */
4700         struct rte_cryptodev_sym_capability_idx cap_idx;
4701         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4702         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4703         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4704                         &cap_idx) == NULL)
4705                 return TEST_SKIPPED;
4706
4707         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4708                 return TEST_SKIPPED;
4709
4710         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4711                 return TEST_SKIPPED;
4712
4713         /* Create SNOW 3G session */
4714         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4715                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4716                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4717                                         tdata->key.data, tdata->key.len,
4718                                         tdata->cipher_iv.len);
4719         if (retval < 0)
4720                 return retval;
4721
4722         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4723         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4724
4725         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4726                         "Failed to allocate input buffer");
4727         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4728                         "Failed to allocate output buffer");
4729
4730         /* Clear mbuf payload */
4731         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4732                rte_pktmbuf_tailroom(ut_params->ibuf));
4733
4734         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4735                        rte_pktmbuf_tailroom(ut_params->obuf));
4736
4737         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4738         /* Append data which is padded to a multiple of */
4739         /* the algorithms block size */
4740         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4741         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4742                                 ciphertext_pad_len);
4743         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4744         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4745
4746         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4747
4748         /* Create SNOW 3G operation */
4749         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4750                                         tdata->cipher_iv.len,
4751                                         tdata->validCipherLenInBits.len,
4752                                         0);
4753         if (retval < 0)
4754                 return retval;
4755
4756         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4757                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4758                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4759         else
4760                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4761                                                 ut_params->op);
4762         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4763         ut_params->obuf = ut_params->op->sym->m_dst;
4764         if (ut_params->obuf)
4765                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4766         else
4767                 plaintext = ciphertext;
4768
4769         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4770
4771         /* Validate obuf */
4772         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4773                                 tdata->plaintext.data,
4774                                 tdata->validDataLenInBits.len,
4775                                 "SNOW 3G Plaintext data not as expected");
4776         return 0;
4777 }
4778
4779 static int
4780 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4781 {
4782         struct crypto_testsuite_params *ts_params = &testsuite_params;
4783         struct crypto_unittest_params *ut_params = &unittest_params;
4784
4785         int retval;
4786
4787         uint8_t *plaintext, *ciphertext;
4788         unsigned int plaintext_pad_len;
4789         unsigned int plaintext_len;
4790
4791         struct rte_cryptodev_info dev_info;
4792         struct rte_cryptodev_sym_capability_idx cap_idx;
4793
4794         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4795         uint64_t feat_flags = dev_info.feature_flags;
4796
4797         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4798                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4799                         (tdata->validDataLenInBits.len % 8 != 0))) {
4800                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4801                 return TEST_SKIPPED;
4802         }
4803
4804         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4805                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4806                 printf("Device doesn't support RAW data-path APIs.\n");
4807                 return TEST_SKIPPED;
4808         }
4809
4810         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4811                 return TEST_SKIPPED;
4812
4813         /* Check if device supports ZUC EEA3 */
4814         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4815         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4816
4817         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4818                         &cap_idx) == NULL)
4819                 return TEST_SKIPPED;
4820
4821         /* Check if device supports ZUC EIA3 */
4822         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4823         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4824
4825         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4826                         &cap_idx) == NULL)
4827                 return TEST_SKIPPED;
4828
4829         /* Create ZUC session */
4830         retval = create_zuc_cipher_auth_encrypt_generate_session(
4831                         ts_params->valid_devs[0],
4832                         tdata);
4833         if (retval != 0)
4834                 return retval;
4835         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4836
4837         /* clear mbuf payload */
4838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4839                         rte_pktmbuf_tailroom(ut_params->ibuf));
4840
4841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4842         /* Append data which is padded to a multiple of */
4843         /* the algorithms block size */
4844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4846                                 plaintext_pad_len);
4847         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4848
4849         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4850
4851         /* Create ZUC operation */
4852         retval = create_zuc_cipher_hash_generate_operation(tdata);
4853         if (retval < 0)
4854                 return retval;
4855
4856         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4857                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4858                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4859         else
4860                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4861                         ut_params->op);
4862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4863         ut_params->obuf = ut_params->op->sym->m_src;
4864         if (ut_params->obuf)
4865                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4866         else
4867                 ciphertext = plaintext;
4868
4869         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4870         /* Validate obuf */
4871         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4872                         ciphertext,
4873                         tdata->ciphertext.data,
4874                         tdata->validDataLenInBits.len,
4875                         "ZUC Ciphertext data not as expected");
4876
4877         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4878             + plaintext_pad_len;
4879
4880         /* Validate obuf */
4881         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4882                         ut_params->digest,
4883                         tdata->digest.data,
4884                         4,
4885                         "ZUC Generated auth tag not as expected");
4886         return 0;
4887 }
4888
4889 static int
4890 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4891 {
4892         struct crypto_testsuite_params *ts_params = &testsuite_params;
4893         struct crypto_unittest_params *ut_params = &unittest_params;
4894
4895         int retval;
4896
4897         uint8_t *plaintext, *ciphertext;
4898         unsigned plaintext_pad_len;
4899         unsigned plaintext_len;
4900         struct rte_cryptodev_info dev_info;
4901
4902         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4903         uint64_t feat_flags = dev_info.feature_flags;
4904
4905         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4906                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4907                 printf("Device doesn't support RAW data-path APIs.\n");
4908                 return TEST_SKIPPED;
4909         }
4910
4911         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4912                 return TEST_SKIPPED;
4913
4914         /* Verify the capabilities */
4915         struct rte_cryptodev_sym_capability_idx cap_idx;
4916         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4917         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4918         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4919                         &cap_idx) == NULL)
4920                 return TEST_SKIPPED;
4921         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4922         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4923         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4924                         &cap_idx) == NULL)
4925                 return TEST_SKIPPED;
4926
4927         /* Create SNOW 3G session */
4928         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4929                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4930                         RTE_CRYPTO_AUTH_OP_GENERATE,
4931                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4932                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4933                         tdata->key.data, tdata->key.len,
4934                         tdata->auth_iv.len, tdata->digest.len,
4935                         tdata->cipher_iv.len);
4936         if (retval != 0)
4937                 return retval;
4938         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4939
4940         /* clear mbuf payload */
4941         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4942                         rte_pktmbuf_tailroom(ut_params->ibuf));
4943
4944         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4945         /* Append data which is padded to a multiple of */
4946         /* the algorithms block size */
4947         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4948         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4949                                 plaintext_pad_len);
4950         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4951
4952         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4953
4954         /* Create SNOW 3G operation */
4955         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4956                         tdata->digest.len, tdata->auth_iv.data,
4957                         tdata->auth_iv.len,
4958                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4959                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4960                         tdata->validCipherLenInBits.len,
4961                         0,
4962                         tdata->validAuthLenInBits.len,
4963                         0
4964                         );
4965         if (retval < 0)
4966                 return retval;
4967
4968         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4969                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4970                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4971         else
4972                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4973                         ut_params->op);
4974         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4975         ut_params->obuf = ut_params->op->sym->m_src;
4976         if (ut_params->obuf)
4977                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4978         else
4979                 ciphertext = plaintext;
4980
4981         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4982         /* Validate obuf */
4983         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4984                         ciphertext,
4985                         tdata->ciphertext.data,
4986                         tdata->validDataLenInBits.len,
4987                         "SNOW 3G Ciphertext data not as expected");
4988
4989         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4990             + plaintext_pad_len;
4991
4992         /* Validate obuf */
4993         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4994                         ut_params->digest,
4995                         tdata->digest.data,
4996                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4997                         "SNOW 3G Generated auth tag not as expected");
4998         return 0;
4999 }
5000
5001 static int
5002 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
5003         uint8_t op_mode, uint8_t verify)
5004 {
5005         struct crypto_testsuite_params *ts_params = &testsuite_params;
5006         struct crypto_unittest_params *ut_params = &unittest_params;
5007
5008         int retval;
5009
5010         uint8_t *plaintext = NULL, *ciphertext = NULL;
5011         unsigned int plaintext_pad_len;
5012         unsigned int plaintext_len;
5013         unsigned int ciphertext_pad_len;
5014         unsigned int ciphertext_len;
5015
5016         struct rte_cryptodev_info dev_info;
5017
5018         /* Verify the capabilities */
5019         struct rte_cryptodev_sym_capability_idx cap_idx;
5020         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5021         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5022         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5023                         &cap_idx) == NULL)
5024                 return TEST_SKIPPED;
5025         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5026         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5027         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5028                         &cap_idx) == NULL)
5029                 return TEST_SKIPPED;
5030
5031         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5032                 return TEST_SKIPPED;
5033
5034         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5035
5036         uint64_t feat_flags = dev_info.feature_flags;
5037
5038         if (op_mode == OUT_OF_PLACE) {
5039                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5040                         printf("Device doesn't support digest encrypted.\n");
5041                         return TEST_SKIPPED;
5042                 }
5043                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5044                         return TEST_SKIPPED;
5045         }
5046
5047         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5048                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5049                 printf("Device doesn't support RAW data-path APIs.\n");
5050                 return TEST_SKIPPED;
5051         }
5052
5053         /* Create SNOW 3G session */
5054         retval = create_wireless_algo_auth_cipher_session(
5055                         ts_params->valid_devs[0],
5056                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5057                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5058                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5059                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5060                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5061                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5062                         tdata->key.data, tdata->key.len,
5063                         tdata->auth_iv.len, tdata->digest.len,
5064                         tdata->cipher_iv.len);
5065         if (retval != 0)
5066                 return retval;
5067
5068         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5069         if (op_mode == OUT_OF_PLACE)
5070                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5071
5072         /* clear mbuf payload */
5073         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5074                 rte_pktmbuf_tailroom(ut_params->ibuf));
5075         if (op_mode == OUT_OF_PLACE)
5076                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5077                         rte_pktmbuf_tailroom(ut_params->obuf));
5078
5079         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5080         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5081         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5082         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5083
5084         if (verify) {
5085                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5086                                         ciphertext_pad_len);
5087                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5088                 if (op_mode == OUT_OF_PLACE)
5089                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5090                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5091                         ciphertext_len);
5092         } else {
5093                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5094                                         plaintext_pad_len);
5095                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5096                 if (op_mode == OUT_OF_PLACE)
5097                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5098                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5099         }
5100
5101         /* Create SNOW 3G operation */
5102         retval = create_wireless_algo_auth_cipher_operation(
5103                 tdata->digest.data, tdata->digest.len,
5104                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5105                 tdata->auth_iv.data, tdata->auth_iv.len,
5106                 (tdata->digest.offset_bytes == 0 ?
5107                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5108                         : tdata->digest.offset_bytes),
5109                 tdata->validCipherLenInBits.len,
5110                 tdata->cipher.offset_bits,
5111                 tdata->validAuthLenInBits.len,
5112                 tdata->auth.offset_bits,
5113                 op_mode, 0, verify);
5114
5115         if (retval < 0)
5116                 return retval;
5117
5118         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5119                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5120                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5121         else
5122                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5123                         ut_params->op);
5124
5125         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5126
5127         ut_params->obuf = (op_mode == IN_PLACE ?
5128                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5129
5130         if (verify) {
5131                 if (ut_params->obuf)
5132                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5133                                                         uint8_t *);
5134                 else
5135                         plaintext = ciphertext +
5136                                 (tdata->cipher.offset_bits >> 3);
5137
5138                 debug_hexdump(stdout, "plaintext:", plaintext,
5139                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5140                 debug_hexdump(stdout, "plaintext expected:",
5141                         tdata->plaintext.data,
5142                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5143         } else {
5144                 if (ut_params->obuf)
5145                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5146                                                         uint8_t *);
5147                 else
5148                         ciphertext = plaintext;
5149
5150                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5151                         ciphertext_len);
5152                 debug_hexdump(stdout, "ciphertext expected:",
5153                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5154
5155                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5156                         + (tdata->digest.offset_bytes == 0 ?
5157                 plaintext_pad_len : tdata->digest.offset_bytes);
5158
5159                 debug_hexdump(stdout, "digest:", ut_params->digest,
5160                         tdata->digest.len);
5161                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5162                                 tdata->digest.len);
5163         }
5164
5165         /* Validate obuf */
5166         if (verify) {
5167                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5168                         plaintext,
5169                         tdata->plaintext.data,
5170                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5171                          (tdata->digest.len << 3)),
5172                         tdata->cipher.offset_bits,
5173                         "SNOW 3G Plaintext data not as expected");
5174         } else {
5175                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5176                         ciphertext,
5177                         tdata->ciphertext.data,
5178                         (tdata->validDataLenInBits.len -
5179                          tdata->cipher.offset_bits),
5180                         tdata->cipher.offset_bits,
5181                         "SNOW 3G Ciphertext data not as expected");
5182
5183                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5184                         ut_params->digest,
5185                         tdata->digest.data,
5186                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5187                         "SNOW 3G Generated auth tag not as expected");
5188         }
5189         return 0;
5190 }
5191
5192 static int
5193 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5194         uint8_t op_mode, uint8_t verify)
5195 {
5196         struct crypto_testsuite_params *ts_params = &testsuite_params;
5197         struct crypto_unittest_params *ut_params = &unittest_params;
5198
5199         int retval;
5200
5201         const uint8_t *plaintext = NULL;
5202         const uint8_t *ciphertext = NULL;
5203         const uint8_t *digest = NULL;
5204         unsigned int plaintext_pad_len;
5205         unsigned int plaintext_len;
5206         unsigned int ciphertext_pad_len;
5207         unsigned int ciphertext_len;
5208         uint8_t buffer[10000];
5209         uint8_t digest_buffer[10000];
5210
5211         struct rte_cryptodev_info dev_info;
5212
5213         /* Verify the capabilities */
5214         struct rte_cryptodev_sym_capability_idx cap_idx;
5215         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5216         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5217         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5218                         &cap_idx) == NULL)
5219                 return TEST_SKIPPED;
5220         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5221         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5222         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5223                         &cap_idx) == NULL)
5224                 return TEST_SKIPPED;
5225
5226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5227                 return TEST_SKIPPED;
5228
5229         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5230
5231         uint64_t feat_flags = dev_info.feature_flags;
5232
5233         if (op_mode == IN_PLACE) {
5234                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5235                         printf("Device doesn't support in-place scatter-gather "
5236                                         "in both input and output mbufs.\n");
5237                         return TEST_SKIPPED;
5238                 }
5239                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5240                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5241                         printf("Device doesn't support RAW data-path APIs.\n");
5242                         return TEST_SKIPPED;
5243                 }
5244         } else {
5245                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5246                         return TEST_SKIPPED;
5247                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5248                         printf("Device doesn't support out-of-place scatter-gather "
5249                                         "in both input and output mbufs.\n");
5250                         return TEST_SKIPPED;
5251                 }
5252                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5253                         printf("Device doesn't support digest encrypted.\n");
5254                         return TEST_SKIPPED;
5255                 }
5256         }
5257
5258         /* Create SNOW 3G session */
5259         retval = create_wireless_algo_auth_cipher_session(
5260                         ts_params->valid_devs[0],
5261                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5262                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5263                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5264                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5265                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5266                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5267                         tdata->key.data, tdata->key.len,
5268                         tdata->auth_iv.len, tdata->digest.len,
5269                         tdata->cipher_iv.len);
5270
5271         if (retval != 0)
5272                 return retval;
5273
5274         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5275         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5276         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5277         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5278
5279         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5280                         plaintext_pad_len, 15, 0);
5281         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5282                         "Failed to allocate input buffer in mempool");
5283
5284         if (op_mode == OUT_OF_PLACE) {
5285                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5286                                 plaintext_pad_len, 15, 0);
5287                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5288                                 "Failed to allocate output buffer in mempool");
5289         }
5290
5291         if (verify) {
5292                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5293                         tdata->ciphertext.data);
5294                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5295                                         ciphertext_len, buffer);
5296                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5297                         ciphertext_len);
5298         } else {
5299                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5300                         tdata->plaintext.data);
5301                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5302                                         plaintext_len, buffer);
5303                 debug_hexdump(stdout, "plaintext:", plaintext,
5304                         plaintext_len);
5305         }
5306         memset(buffer, 0, sizeof(buffer));
5307
5308         /* Create SNOW 3G operation */
5309         retval = create_wireless_algo_auth_cipher_operation(
5310                 tdata->digest.data, tdata->digest.len,
5311                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5312                 tdata->auth_iv.data, tdata->auth_iv.len,
5313                 (tdata->digest.offset_bytes == 0 ?
5314                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5315                         : tdata->digest.offset_bytes),
5316                 tdata->validCipherLenInBits.len,
5317                 tdata->cipher.offset_bits,
5318                 tdata->validAuthLenInBits.len,
5319                 tdata->auth.offset_bits,
5320                 op_mode, 1, verify);
5321
5322         if (retval < 0)
5323                 return retval;
5324
5325         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5326                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5327                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5328         else
5329                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5330                         ut_params->op);
5331
5332         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5333
5334         ut_params->obuf = (op_mode == IN_PLACE ?
5335                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5336
5337         if (verify) {
5338                 if (ut_params->obuf)
5339                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5340                                         plaintext_len, buffer);
5341                 else
5342                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5343                                         plaintext_len, buffer);
5344
5345                 debug_hexdump(stdout, "plaintext:", plaintext,
5346                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5347                 debug_hexdump(stdout, "plaintext expected:",
5348                         tdata->plaintext.data,
5349                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5350         } else {
5351                 if (ut_params->obuf)
5352                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5353                                         ciphertext_len, buffer);
5354                 else
5355                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5356                                         ciphertext_len, buffer);
5357
5358                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5359                         ciphertext_len);
5360                 debug_hexdump(stdout, "ciphertext expected:",
5361                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5362
5363                 if (ut_params->obuf)
5364                         digest = rte_pktmbuf_read(ut_params->obuf,
5365                                 (tdata->digest.offset_bytes == 0 ?
5366                                 plaintext_pad_len : tdata->digest.offset_bytes),
5367                                 tdata->digest.len, digest_buffer);
5368                 else
5369                         digest = rte_pktmbuf_read(ut_params->ibuf,
5370                                 (tdata->digest.offset_bytes == 0 ?
5371                                 plaintext_pad_len : tdata->digest.offset_bytes),
5372                                 tdata->digest.len, digest_buffer);
5373
5374                 debug_hexdump(stdout, "digest:", digest,
5375                         tdata->digest.len);
5376                 debug_hexdump(stdout, "digest expected:",
5377                         tdata->digest.data, tdata->digest.len);
5378         }
5379
5380         /* Validate obuf */
5381         if (verify) {
5382                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5383                         plaintext,
5384                         tdata->plaintext.data,
5385                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5386                          (tdata->digest.len << 3)),
5387                         tdata->cipher.offset_bits,
5388                         "SNOW 3G Plaintext data not as expected");
5389         } else {
5390                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5391                         ciphertext,
5392                         tdata->ciphertext.data,
5393                         (tdata->validDataLenInBits.len -
5394                          tdata->cipher.offset_bits),
5395                         tdata->cipher.offset_bits,
5396                         "SNOW 3G Ciphertext data not as expected");
5397
5398                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5399                         digest,
5400                         tdata->digest.data,
5401                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5402                         "SNOW 3G Generated auth tag not as expected");
5403         }
5404         return 0;
5405 }
5406
5407 static int
5408 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5409         uint8_t op_mode, uint8_t verify)
5410 {
5411         struct crypto_testsuite_params *ts_params = &testsuite_params;
5412         struct crypto_unittest_params *ut_params = &unittest_params;
5413
5414         int retval;
5415
5416         uint8_t *plaintext = NULL, *ciphertext = NULL;
5417         unsigned int plaintext_pad_len;
5418         unsigned int plaintext_len;
5419         unsigned int ciphertext_pad_len;
5420         unsigned int ciphertext_len;
5421
5422         struct rte_cryptodev_info dev_info;
5423
5424         /* Verify the capabilities */
5425         struct rte_cryptodev_sym_capability_idx cap_idx;
5426         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5427         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5428         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5429                         &cap_idx) == NULL)
5430                 return TEST_SKIPPED;
5431         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5432         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5433         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5434                         &cap_idx) == NULL)
5435                 return TEST_SKIPPED;
5436
5437         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438
5439         uint64_t feat_flags = dev_info.feature_flags;
5440
5441         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5442                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5443                 printf("Device doesn't support RAW data-path APIs.\n");
5444                 return TEST_SKIPPED;
5445         }
5446
5447         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5448                 return TEST_SKIPPED;
5449
5450         if (op_mode == OUT_OF_PLACE) {
5451                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5452                         return TEST_SKIPPED;
5453                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5454                         printf("Device doesn't support digest encrypted.\n");
5455                         return TEST_SKIPPED;
5456                 }
5457         }
5458
5459         /* Create KASUMI session */
5460         retval = create_wireless_algo_auth_cipher_session(
5461                         ts_params->valid_devs[0],
5462                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5463                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5464                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5465                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5466                         RTE_CRYPTO_AUTH_KASUMI_F9,
5467                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5468                         tdata->key.data, tdata->key.len,
5469                         0, tdata->digest.len,
5470                         tdata->cipher_iv.len);
5471
5472         if (retval != 0)
5473                 return retval;
5474
5475         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5476         if (op_mode == OUT_OF_PLACE)
5477                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5478
5479         /* clear mbuf payload */
5480         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5481                 rte_pktmbuf_tailroom(ut_params->ibuf));
5482         if (op_mode == OUT_OF_PLACE)
5483                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5484                         rte_pktmbuf_tailroom(ut_params->obuf));
5485
5486         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5487         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5488         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5489         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5490
5491         if (verify) {
5492                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5493                                         ciphertext_pad_len);
5494                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5495                 if (op_mode == OUT_OF_PLACE)
5496                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5497                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5498                         ciphertext_len);
5499         } else {
5500                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5501                                         plaintext_pad_len);
5502                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5503                 if (op_mode == OUT_OF_PLACE)
5504                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5505                 debug_hexdump(stdout, "plaintext:", plaintext,
5506                         plaintext_len);
5507         }
5508
5509         /* Create KASUMI operation */
5510         retval = create_wireless_algo_auth_cipher_operation(
5511                 tdata->digest.data, tdata->digest.len,
5512                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5513                 NULL, 0,
5514                 (tdata->digest.offset_bytes == 0 ?
5515                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5516                         : tdata->digest.offset_bytes),
5517                 tdata->validCipherLenInBits.len,
5518                 tdata->validCipherOffsetInBits.len,
5519                 tdata->validAuthLenInBits.len,
5520                 0,
5521                 op_mode, 0, verify);
5522
5523         if (retval < 0)
5524                 return retval;
5525
5526         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5527                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5528                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5529         else
5530                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5531                         ut_params->op);
5532
5533         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5534
5535         ut_params->obuf = (op_mode == IN_PLACE ?
5536                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5537
5538
5539         if (verify) {
5540                 if (ut_params->obuf)
5541                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5542                                                         uint8_t *);
5543                 else
5544                         plaintext = ciphertext;
5545
5546                 debug_hexdump(stdout, "plaintext:", plaintext,
5547                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5548                 debug_hexdump(stdout, "plaintext expected:",
5549                         tdata->plaintext.data,
5550                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5551         } else {
5552                 if (ut_params->obuf)
5553                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5554                                                         uint8_t *);
5555                 else
5556                         ciphertext = plaintext;
5557
5558                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5559                         ciphertext_len);
5560                 debug_hexdump(stdout, "ciphertext expected:",
5561                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5562
5563                 ut_params->digest = rte_pktmbuf_mtod(
5564                         ut_params->obuf, uint8_t *) +
5565                         (tdata->digest.offset_bytes == 0 ?
5566                         plaintext_pad_len : tdata->digest.offset_bytes);
5567
5568                 debug_hexdump(stdout, "digest:", ut_params->digest,
5569                         tdata->digest.len);
5570                 debug_hexdump(stdout, "digest expected:",
5571                         tdata->digest.data, tdata->digest.len);
5572         }
5573
5574         /* Validate obuf */
5575         if (verify) {
5576                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5577                         plaintext,
5578                         tdata->plaintext.data,
5579                         tdata->plaintext.len >> 3,
5580                         "KASUMI Plaintext data not as expected");
5581         } else {
5582                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5583                         ciphertext,
5584                         tdata->ciphertext.data,
5585                         tdata->ciphertext.len >> 3,
5586                         "KASUMI Ciphertext data not as expected");
5587
5588                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5589                         ut_params->digest,
5590                         tdata->digest.data,
5591                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5592                         "KASUMI Generated auth tag not as expected");
5593         }
5594         return 0;
5595 }
5596
5597 static int
5598 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5599         uint8_t op_mode, uint8_t verify)
5600 {
5601         struct crypto_testsuite_params *ts_params = &testsuite_params;
5602         struct crypto_unittest_params *ut_params = &unittest_params;
5603
5604         int retval;
5605
5606         const uint8_t *plaintext = NULL;
5607         const uint8_t *ciphertext = NULL;
5608         const uint8_t *digest = NULL;
5609         unsigned int plaintext_pad_len;
5610         unsigned int plaintext_len;
5611         unsigned int ciphertext_pad_len;
5612         unsigned int ciphertext_len;
5613         uint8_t buffer[10000];
5614         uint8_t digest_buffer[10000];
5615
5616         struct rte_cryptodev_info dev_info;
5617
5618         /* Verify the capabilities */
5619         struct rte_cryptodev_sym_capability_idx cap_idx;
5620         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5621         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5622         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5623                         &cap_idx) == NULL)
5624                 return TEST_SKIPPED;
5625         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5626         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5627         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5628                         &cap_idx) == NULL)
5629                 return TEST_SKIPPED;
5630
5631         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5632                 return TEST_SKIPPED;
5633
5634         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5635
5636         uint64_t feat_flags = dev_info.feature_flags;
5637
5638         if (op_mode == IN_PLACE) {
5639                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5640                         printf("Device doesn't support in-place scatter-gather "
5641                                         "in both input and output mbufs.\n");
5642                         return TEST_SKIPPED;
5643                 }
5644                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646                         printf("Device doesn't support RAW data-path APIs.\n");
5647                         return TEST_SKIPPED;
5648                 }
5649         } else {
5650                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5651                         return TEST_SKIPPED;
5652                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5653                         printf("Device doesn't support out-of-place scatter-gather "
5654                                         "in both input and output mbufs.\n");
5655                         return TEST_SKIPPED;
5656                 }
5657                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5658                         printf("Device doesn't support digest encrypted.\n");
5659                         return TEST_SKIPPED;
5660                 }
5661         }
5662
5663         /* Create KASUMI session */
5664         retval = create_wireless_algo_auth_cipher_session(
5665                         ts_params->valid_devs[0],
5666                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5667                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5668                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5669                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5670                         RTE_CRYPTO_AUTH_KASUMI_F9,
5671                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5672                         tdata->key.data, tdata->key.len,
5673                         0, tdata->digest.len,
5674                         tdata->cipher_iv.len);
5675
5676         if (retval != 0)
5677                 return retval;
5678
5679         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5680         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5681         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5682         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5683
5684         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5685                         plaintext_pad_len, 15, 0);
5686         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5687                         "Failed to allocate input buffer in mempool");
5688
5689         if (op_mode == OUT_OF_PLACE) {
5690                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5691                                 plaintext_pad_len, 15, 0);
5692                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5693                                 "Failed to allocate output buffer in mempool");
5694         }
5695
5696         if (verify) {
5697                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5698                         tdata->ciphertext.data);
5699                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5700                                         ciphertext_len, buffer);
5701                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5702                         ciphertext_len);
5703         } else {
5704                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5705                         tdata->plaintext.data);
5706                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5707                                         plaintext_len, buffer);
5708                 debug_hexdump(stdout, "plaintext:", plaintext,
5709                         plaintext_len);
5710         }
5711         memset(buffer, 0, sizeof(buffer));
5712
5713         /* Create KASUMI operation */
5714         retval = create_wireless_algo_auth_cipher_operation(
5715                 tdata->digest.data, tdata->digest.len,
5716                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5717                 NULL, 0,
5718                 (tdata->digest.offset_bytes == 0 ?
5719                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5720                         : tdata->digest.offset_bytes),
5721                 tdata->validCipherLenInBits.len,
5722                 tdata->validCipherOffsetInBits.len,
5723                 tdata->validAuthLenInBits.len,
5724                 0,
5725                 op_mode, 1, verify);
5726
5727         if (retval < 0)
5728                 return retval;
5729
5730         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5731                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5732                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5733         else
5734                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5735                         ut_params->op);
5736
5737         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5738
5739         ut_params->obuf = (op_mode == IN_PLACE ?
5740                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5741
5742         if (verify) {
5743                 if (ut_params->obuf)
5744                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5745                                         plaintext_len, buffer);
5746                 else
5747                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5748                                         plaintext_len, buffer);
5749
5750                 debug_hexdump(stdout, "plaintext:", plaintext,
5751                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5752                 debug_hexdump(stdout, "plaintext expected:",
5753                         tdata->plaintext.data,
5754                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5755         } else {
5756                 if (ut_params->obuf)
5757                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5758                                         ciphertext_len, buffer);
5759                 else
5760                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5761                                         ciphertext_len, buffer);
5762
5763                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5764                         ciphertext_len);
5765                 debug_hexdump(stdout, "ciphertext expected:",
5766                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5767
5768                 if (ut_params->obuf)
5769                         digest = rte_pktmbuf_read(ut_params->obuf,
5770                                 (tdata->digest.offset_bytes == 0 ?
5771                                 plaintext_pad_len : tdata->digest.offset_bytes),
5772                                 tdata->digest.len, digest_buffer);
5773                 else
5774                         digest = rte_pktmbuf_read(ut_params->ibuf,
5775                                 (tdata->digest.offset_bytes == 0 ?
5776                                 plaintext_pad_len : tdata->digest.offset_bytes),
5777                                 tdata->digest.len, digest_buffer);
5778
5779                 debug_hexdump(stdout, "digest:", digest,
5780                         tdata->digest.len);
5781                 debug_hexdump(stdout, "digest expected:",
5782                         tdata->digest.data, tdata->digest.len);
5783         }
5784
5785         /* Validate obuf */
5786         if (verify) {
5787                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5788                         plaintext,
5789                         tdata->plaintext.data,
5790                         tdata->plaintext.len >> 3,
5791                         "KASUMI Plaintext data not as expected");
5792         } else {
5793                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5794                         ciphertext,
5795                         tdata->ciphertext.data,
5796                         tdata->validDataLenInBits.len,
5797                         "KASUMI Ciphertext data not as expected");
5798
5799                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5800                         digest,
5801                         tdata->digest.data,
5802                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5803                         "KASUMI Generated auth tag not as expected");
5804         }
5805         return 0;
5806 }
5807
5808 static int
5809 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5810 {
5811         struct crypto_testsuite_params *ts_params = &testsuite_params;
5812         struct crypto_unittest_params *ut_params = &unittest_params;
5813
5814         int retval;
5815
5816         uint8_t *plaintext, *ciphertext;
5817         unsigned plaintext_pad_len;
5818         unsigned plaintext_len;
5819         struct rte_cryptodev_info dev_info;
5820
5821         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5822         uint64_t feat_flags = dev_info.feature_flags;
5823
5824         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5825                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5826                 printf("Device doesn't support RAW data-path APIs.\n");
5827                 return TEST_SKIPPED;
5828         }
5829
5830         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5831                 return TEST_SKIPPED;
5832
5833         /* Verify the capabilities */
5834         struct rte_cryptodev_sym_capability_idx cap_idx;
5835         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5836         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5837         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5838                         &cap_idx) == NULL)
5839                 return TEST_SKIPPED;
5840         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5841         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5842         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5843                         &cap_idx) == NULL)
5844                 return TEST_SKIPPED;
5845
5846         /* Create KASUMI session */
5847         retval = create_wireless_algo_cipher_auth_session(
5848                         ts_params->valid_devs[0],
5849                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5850                         RTE_CRYPTO_AUTH_OP_GENERATE,
5851                         RTE_CRYPTO_AUTH_KASUMI_F9,
5852                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5853                         tdata->key.data, tdata->key.len,
5854                         0, tdata->digest.len,
5855                         tdata->cipher_iv.len);
5856         if (retval != 0)
5857                 return retval;
5858
5859         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5860
5861         /* clear mbuf payload */
5862         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5863                         rte_pktmbuf_tailroom(ut_params->ibuf));
5864
5865         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5866         /* Append data which is padded to a multiple of */
5867         /* the algorithms block size */
5868         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5869         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5870                                 plaintext_pad_len);
5871         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5872
5873         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5874
5875         /* Create KASUMI operation */
5876         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5877                                 tdata->digest.len, NULL, 0,
5878                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5879                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5880                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5881                                 tdata->validCipherOffsetInBits.len,
5882                                 tdata->validAuthLenInBits.len,
5883                                 0
5884                                 );
5885         if (retval < 0)
5886                 return retval;
5887
5888         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5889                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5890                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5891         else
5892                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5893                         ut_params->op);
5894         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5895
5896         if (ut_params->op->sym->m_dst)
5897                 ut_params->obuf = ut_params->op->sym->m_dst;
5898         else
5899                 ut_params->obuf = ut_params->op->sym->m_src;
5900
5901         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5902                                 tdata->validCipherOffsetInBits.len >> 3);
5903
5904         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5905                         + plaintext_pad_len;
5906
5907         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5908                                 (tdata->validCipherOffsetInBits.len >> 3);
5909         /* Validate obuf */
5910         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5911                 ciphertext,
5912                 reference_ciphertext,
5913                 tdata->validCipherLenInBits.len,
5914                 "KASUMI Ciphertext data not as expected");
5915
5916         /* Validate obuf */
5917         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5918                 ut_params->digest,
5919                 tdata->digest.data,
5920                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5921                 "KASUMI Generated auth tag not as expected");
5922         return 0;
5923 }
5924
5925 static int
5926 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5927                         const enum rte_crypto_cipher_algorithm cipher_algo,
5928                         const uint16_t key_size, const uint16_t iv_size)
5929 {
5930         struct rte_cryptodev_sym_capability_idx cap_idx;
5931         const struct rte_cryptodev_symmetric_capability *cap;
5932
5933         /* Check if device supports the algorithm */
5934         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5935         cap_idx.algo.cipher = cipher_algo;
5936
5937         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5938                         &cap_idx);
5939
5940         if (cap == NULL)
5941                 return -1;
5942
5943         /* Check if device supports key size and IV size */
5944         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5945                         iv_size) < 0) {
5946                 return -1;
5947         }
5948
5949         return 0;
5950 }
5951
5952 static int
5953 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5954                         const enum rte_crypto_auth_algorithm auth_algo,
5955                         const uint16_t key_size, const uint16_t iv_size,
5956                         const uint16_t tag_size)
5957 {
5958         struct rte_cryptodev_sym_capability_idx cap_idx;
5959         const struct rte_cryptodev_symmetric_capability *cap;
5960
5961         /* Check if device supports the algorithm */
5962         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5963         cap_idx.algo.auth = auth_algo;
5964
5965         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5966                         &cap_idx);
5967
5968         if (cap == NULL)
5969                 return -1;
5970
5971         /* Check if device supports key size and IV size */
5972         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5973                         tag_size, iv_size) < 0) {
5974                 return -1;
5975         }
5976
5977         return 0;
5978 }
5979
5980 static int
5981 test_zuc_encryption(const struct wireless_test_data *tdata)
5982 {
5983         struct crypto_testsuite_params *ts_params = &testsuite_params;
5984         struct crypto_unittest_params *ut_params = &unittest_params;
5985
5986         int retval;
5987         uint8_t *plaintext, *ciphertext;
5988         unsigned plaintext_pad_len;
5989         unsigned plaintext_len;
5990         struct rte_cryptodev_info dev_info;
5991
5992         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5993         uint64_t feat_flags = dev_info.feature_flags;
5994
5995         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5996                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5997                 printf("Device doesn't support RAW data-path APIs.\n");
5998                 return TEST_SKIPPED;
5999         }
6000
6001         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6002                 return TEST_SKIPPED;
6003
6004         /* Check if device supports ZUC EEA3 */
6005         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6006                         tdata->key.len, tdata->cipher_iv.len) < 0)
6007                 return TEST_SKIPPED;
6008
6009         /* Create ZUC session */
6010         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6011                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6012                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6013                                         tdata->key.data, tdata->key.len,
6014                                         tdata->cipher_iv.len);
6015         if (retval != 0)
6016                 return retval;
6017
6018         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6019
6020         /* Clear mbuf payload */
6021         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6022                rte_pktmbuf_tailroom(ut_params->ibuf));
6023
6024         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6025         /* Append data which is padded to a multiple */
6026         /* of the algorithms block size */
6027         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6028         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6029                                 plaintext_pad_len);
6030         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6031
6032         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6033
6034         /* Create ZUC operation */
6035         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6036                                         tdata->cipher_iv.len,
6037                                         tdata->plaintext.len,
6038                                         0);
6039         if (retval < 0)
6040                 return retval;
6041
6042         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6043                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6044                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6045         else
6046                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6047                                                 ut_params->op);
6048         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6049
6050         ut_params->obuf = ut_params->op->sym->m_dst;
6051         if (ut_params->obuf)
6052                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6053         else
6054                 ciphertext = plaintext;
6055
6056         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6057
6058         /* Validate obuf */
6059         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6060                 ciphertext,
6061                 tdata->ciphertext.data,
6062                 tdata->validCipherLenInBits.len,
6063                 "ZUC Ciphertext data not as expected");
6064         return 0;
6065 }
6066
6067 static int
6068 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6069 {
6070         struct crypto_testsuite_params *ts_params = &testsuite_params;
6071         struct crypto_unittest_params *ut_params = &unittest_params;
6072
6073         int retval;
6074
6075         unsigned int plaintext_pad_len;
6076         unsigned int plaintext_len;
6077         const uint8_t *ciphertext;
6078         uint8_t ciphertext_buffer[2048];
6079         struct rte_cryptodev_info dev_info;
6080
6081         /* Check if device supports ZUC EEA3 */
6082         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6083                         tdata->key.len, tdata->cipher_iv.len) < 0)
6084                 return TEST_SKIPPED;
6085
6086         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6087                 return TEST_SKIPPED;
6088
6089         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6090
6091         uint64_t feat_flags = dev_info.feature_flags;
6092
6093         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6094                 printf("Device doesn't support in-place scatter-gather. "
6095                                 "Test Skipped.\n");
6096                 return TEST_SKIPPED;
6097         }
6098
6099         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6100                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6101                 printf("Device doesn't support RAW data-path APIs.\n");
6102                 return TEST_SKIPPED;
6103         }
6104
6105         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6106
6107         /* Append data which is padded to a multiple */
6108         /* of the algorithms block size */
6109         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6110
6111         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6112                         plaintext_pad_len, 10, 0);
6113
6114         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6115                         tdata->plaintext.data);
6116
6117         /* Create ZUC session */
6118         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6119                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6120                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6121                         tdata->key.data, tdata->key.len,
6122                         tdata->cipher_iv.len);
6123         if (retval < 0)
6124                 return retval;
6125
6126         /* Clear mbuf payload */
6127
6128         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6129
6130         /* Create ZUC operation */
6131         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6132                         tdata->cipher_iv.len, tdata->plaintext.len,
6133                         0);
6134         if (retval < 0)
6135                 return retval;
6136
6137         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6138                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6139                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6140         else
6141                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6142                                                 ut_params->op);
6143         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6144
6145         ut_params->obuf = ut_params->op->sym->m_dst;
6146         if (ut_params->obuf)
6147                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6148                         0, plaintext_len, ciphertext_buffer);
6149         else
6150                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6151                         0, plaintext_len, ciphertext_buffer);
6152
6153         /* Validate obuf */
6154         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6155
6156         /* Validate obuf */
6157         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6158                 ciphertext,
6159                 tdata->ciphertext.data,
6160                 tdata->validCipherLenInBits.len,
6161                 "ZUC Ciphertext data not as expected");
6162
6163         return 0;
6164 }
6165
6166 static int
6167 test_zuc_authentication(const struct wireless_test_data *tdata)
6168 {
6169         struct crypto_testsuite_params *ts_params = &testsuite_params;
6170         struct crypto_unittest_params *ut_params = &unittest_params;
6171
6172         int retval;
6173         unsigned plaintext_pad_len;
6174         unsigned plaintext_len;
6175         uint8_t *plaintext;
6176
6177         struct rte_cryptodev_info dev_info;
6178
6179         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6180         uint64_t feat_flags = dev_info.feature_flags;
6181
6182         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6183                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6184                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6185                 return TEST_SKIPPED;
6186         }
6187
6188         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6189                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6190                 printf("Device doesn't support RAW data-path APIs.\n");
6191                 return TEST_SKIPPED;
6192         }
6193
6194         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6195                 return TEST_SKIPPED;
6196
6197         /* Check if device supports ZUC EIA3 */
6198         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6199                         tdata->key.len, tdata->auth_iv.len,
6200                         tdata->digest.len) < 0)
6201                 return TEST_SKIPPED;
6202
6203         /* Create ZUC session */
6204         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6205                         tdata->key.data, tdata->key.len,
6206                         tdata->auth_iv.len, tdata->digest.len,
6207                         RTE_CRYPTO_AUTH_OP_GENERATE,
6208                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6209         if (retval != 0)
6210                 return retval;
6211
6212         /* alloc mbuf and set payload */
6213         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6214
6215         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6216         rte_pktmbuf_tailroom(ut_params->ibuf));
6217
6218         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6219         /* Append data which is padded to a multiple of */
6220         /* the algorithms block size */
6221         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6222         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6223                                 plaintext_pad_len);
6224         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6225
6226         /* Create ZUC operation */
6227         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6228                         tdata->auth_iv.data, tdata->auth_iv.len,
6229                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6230                         tdata->validAuthLenInBits.len,
6231                         0);
6232         if (retval < 0)
6233                 return retval;
6234
6235         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6236                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6237                                 ut_params->op, 0, 1, 1, 0);
6238         else
6239                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6240                                 ut_params->op);
6241         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6242         ut_params->obuf = ut_params->op->sym->m_src;
6243         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6244                         + plaintext_pad_len;
6245
6246         /* Validate obuf */
6247         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6248         ut_params->digest,
6249         tdata->digest.data,
6250         tdata->digest.len,
6251         "ZUC Generated auth tag not as expected");
6252
6253         return 0;
6254 }
6255
6256 static int
6257 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6258         uint8_t op_mode, uint8_t verify)
6259 {
6260         struct crypto_testsuite_params *ts_params = &testsuite_params;
6261         struct crypto_unittest_params *ut_params = &unittest_params;
6262
6263         int retval;
6264
6265         uint8_t *plaintext = NULL, *ciphertext = NULL;
6266         unsigned int plaintext_pad_len;
6267         unsigned int plaintext_len;
6268         unsigned int ciphertext_pad_len;
6269         unsigned int ciphertext_len;
6270
6271         struct rte_cryptodev_info dev_info;
6272
6273         /* Check if device supports ZUC EEA3 */
6274         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6275                         tdata->key.len, tdata->cipher_iv.len) < 0)
6276                 return TEST_SKIPPED;
6277
6278         /* Check if device supports ZUC EIA3 */
6279         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6280                         tdata->key.len, tdata->auth_iv.len,
6281                         tdata->digest.len) < 0)
6282                 return TEST_SKIPPED;
6283
6284         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6285
6286         uint64_t feat_flags = dev_info.feature_flags;
6287
6288         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6289                 printf("Device doesn't support digest encrypted.\n");
6290                 return TEST_SKIPPED;
6291         }
6292         if (op_mode == IN_PLACE) {
6293                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6294                         printf("Device doesn't support in-place scatter-gather "
6295                                         "in both input and output mbufs.\n");
6296                         return TEST_SKIPPED;
6297                 }
6298
6299                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6300                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6301                         printf("Device doesn't support RAW data-path APIs.\n");
6302                         return TEST_SKIPPED;
6303                 }
6304         } else {
6305                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6306                         return TEST_SKIPPED;
6307                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6308                         printf("Device doesn't support out-of-place scatter-gather "
6309                                         "in both input and output mbufs.\n");
6310                         return TEST_SKIPPED;
6311                 }
6312         }
6313
6314         /* Create ZUC session */
6315         retval = create_wireless_algo_auth_cipher_session(
6316                         ts_params->valid_devs[0],
6317                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6318                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6319                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6320                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6321                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6322                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6323                         tdata->key.data, tdata->key.len,
6324                         tdata->auth_iv.len, tdata->digest.len,
6325                         tdata->cipher_iv.len);
6326
6327         if (retval != 0)
6328                 return retval;
6329
6330         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6331         if (op_mode == OUT_OF_PLACE)
6332                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6333
6334         /* clear mbuf payload */
6335         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6336                 rte_pktmbuf_tailroom(ut_params->ibuf));
6337         if (op_mode == OUT_OF_PLACE)
6338                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6339                         rte_pktmbuf_tailroom(ut_params->obuf));
6340
6341         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6342         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6343         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6344         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6345
6346         if (verify) {
6347                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6348                                         ciphertext_pad_len);
6349                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6350                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6351                         ciphertext_len);
6352         } else {
6353                 /* make sure enough space to cover partial digest verify case */
6354                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6355                                         ciphertext_pad_len);
6356                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6357                 debug_hexdump(stdout, "plaintext:", plaintext,
6358                         plaintext_len);
6359         }
6360
6361         if (op_mode == OUT_OF_PLACE)
6362                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6363
6364         /* Create ZUC operation */
6365         retval = create_wireless_algo_auth_cipher_operation(
6366                 tdata->digest.data, tdata->digest.len,
6367                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6368                 tdata->auth_iv.data, tdata->auth_iv.len,
6369                 (tdata->digest.offset_bytes == 0 ?
6370                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6371                         : tdata->digest.offset_bytes),
6372                 tdata->validCipherLenInBits.len,
6373                 tdata->validCipherOffsetInBits.len,
6374                 tdata->validAuthLenInBits.len,
6375                 0,
6376                 op_mode, 0, verify);
6377
6378         if (retval < 0)
6379                 return retval;
6380
6381         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6382                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6383                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6384         else
6385                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6386                         ut_params->op);
6387
6388         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6389
6390         ut_params->obuf = (op_mode == IN_PLACE ?
6391                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6392
6393
6394         if (verify) {
6395                 if (ut_params->obuf)
6396                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6397                                                         uint8_t *);
6398                 else
6399                         plaintext = ciphertext;
6400
6401                 debug_hexdump(stdout, "plaintext:", plaintext,
6402                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6403                 debug_hexdump(stdout, "plaintext expected:",
6404                         tdata->plaintext.data,
6405                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6406         } else {
6407                 if (ut_params->obuf)
6408                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6409                                                         uint8_t *);
6410                 else
6411                         ciphertext = plaintext;
6412
6413                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6414                         ciphertext_len);
6415                 debug_hexdump(stdout, "ciphertext expected:",
6416                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6417
6418                 ut_params->digest = rte_pktmbuf_mtod(
6419                         ut_params->obuf, uint8_t *) +
6420                         (tdata->digest.offset_bytes == 0 ?
6421                         plaintext_pad_len : tdata->digest.offset_bytes);
6422
6423                 debug_hexdump(stdout, "digest:", ut_params->digest,
6424                         tdata->digest.len);
6425                 debug_hexdump(stdout, "digest expected:",
6426                         tdata->digest.data, tdata->digest.len);
6427         }
6428
6429         /* Validate obuf */
6430         if (verify) {
6431                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6432                         plaintext,
6433                         tdata->plaintext.data,
6434                         tdata->plaintext.len >> 3,
6435                         "ZUC Plaintext data not as expected");
6436         } else {
6437                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6438                         ciphertext,
6439                         tdata->ciphertext.data,
6440                         tdata->ciphertext.len >> 3,
6441                         "ZUC Ciphertext data not as expected");
6442
6443                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6444                         ut_params->digest,
6445                         tdata->digest.data,
6446                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6447                         "ZUC Generated auth tag not as expected");
6448         }
6449         return 0;
6450 }
6451
6452 static int
6453 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6454         uint8_t op_mode, uint8_t verify)
6455 {
6456         struct crypto_testsuite_params *ts_params = &testsuite_params;
6457         struct crypto_unittest_params *ut_params = &unittest_params;
6458
6459         int retval;
6460
6461         const uint8_t *plaintext = NULL;
6462         const uint8_t *ciphertext = NULL;
6463         const uint8_t *digest = NULL;
6464         unsigned int plaintext_pad_len;
6465         unsigned int plaintext_len;
6466         unsigned int ciphertext_pad_len;
6467         unsigned int ciphertext_len;
6468         uint8_t buffer[10000];
6469         uint8_t digest_buffer[10000];
6470
6471         struct rte_cryptodev_info dev_info;
6472
6473         /* Check if device supports ZUC EEA3 */
6474         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6475                         tdata->key.len, tdata->cipher_iv.len) < 0)
6476                 return TEST_SKIPPED;
6477
6478         /* Check if device supports ZUC EIA3 */
6479         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6480                         tdata->key.len, tdata->auth_iv.len,
6481                         tdata->digest.len) < 0)
6482                 return TEST_SKIPPED;
6483
6484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6485
6486         uint64_t feat_flags = dev_info.feature_flags;
6487
6488         if (op_mode == IN_PLACE) {
6489                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6490                         printf("Device doesn't support in-place scatter-gather "
6491                                         "in both input and output mbufs.\n");
6492                         return TEST_SKIPPED;
6493                 }
6494
6495                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6496                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6497                         printf("Device doesn't support RAW data-path APIs.\n");
6498                         return TEST_SKIPPED;
6499                 }
6500         } else {
6501                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6502                         return TEST_SKIPPED;
6503                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6504                         printf("Device doesn't support out-of-place scatter-gather "
6505                                         "in both input and output mbufs.\n");
6506                         return TEST_SKIPPED;
6507                 }
6508                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6509                         printf("Device doesn't support digest encrypted.\n");
6510                         return TEST_SKIPPED;
6511                 }
6512         }
6513
6514         /* Create ZUC session */
6515         retval = create_wireless_algo_auth_cipher_session(
6516                         ts_params->valid_devs[0],
6517                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6518                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6519                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6520                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6521                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6522                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6523                         tdata->key.data, tdata->key.len,
6524                         tdata->auth_iv.len, tdata->digest.len,
6525                         tdata->cipher_iv.len);
6526
6527         if (retval != 0)
6528                 return retval;
6529
6530         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6531         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6532         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6534
6535         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6536                         plaintext_pad_len, 15, 0);
6537         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6538                         "Failed to allocate input buffer in mempool");
6539
6540         if (op_mode == OUT_OF_PLACE) {
6541                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6542                                 plaintext_pad_len, 15, 0);
6543                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6544                                 "Failed to allocate output buffer in mempool");
6545         }
6546
6547         if (verify) {
6548                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6549                         tdata->ciphertext.data);
6550                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6551                                         ciphertext_len, buffer);
6552                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6553                         ciphertext_len);
6554         } else {
6555                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6556                         tdata->plaintext.data);
6557                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6558                                         plaintext_len, buffer);
6559                 debug_hexdump(stdout, "plaintext:", plaintext,
6560                         plaintext_len);
6561         }
6562         memset(buffer, 0, sizeof(buffer));
6563
6564         /* Create ZUC operation */
6565         retval = create_wireless_algo_auth_cipher_operation(
6566                 tdata->digest.data, tdata->digest.len,
6567                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6568                 NULL, 0,
6569                 (tdata->digest.offset_bytes == 0 ?
6570                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6571                         : tdata->digest.offset_bytes),
6572                 tdata->validCipherLenInBits.len,
6573                 tdata->validCipherOffsetInBits.len,
6574                 tdata->validAuthLenInBits.len,
6575                 0,
6576                 op_mode, 1, verify);
6577
6578         if (retval < 0)
6579                 return retval;
6580
6581         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6582                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6583                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6584         else
6585                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6586                         ut_params->op);
6587
6588         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6589
6590         ut_params->obuf = (op_mode == IN_PLACE ?
6591                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6592
6593         if (verify) {
6594                 if (ut_params->obuf)
6595                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6596                                         plaintext_len, buffer);
6597                 else
6598                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6599                                         plaintext_len, buffer);
6600
6601                 debug_hexdump(stdout, "plaintext:", plaintext,
6602                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6603                 debug_hexdump(stdout, "plaintext expected:",
6604                         tdata->plaintext.data,
6605                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6606         } else {
6607                 if (ut_params->obuf)
6608                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6609                                         ciphertext_len, buffer);
6610                 else
6611                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6612                                         ciphertext_len, buffer);
6613
6614                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6615                         ciphertext_len);
6616                 debug_hexdump(stdout, "ciphertext expected:",
6617                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6618
6619                 if (ut_params->obuf)
6620                         digest = rte_pktmbuf_read(ut_params->obuf,
6621                                 (tdata->digest.offset_bytes == 0 ?
6622                                 plaintext_pad_len : tdata->digest.offset_bytes),
6623                                 tdata->digest.len, digest_buffer);
6624                 else
6625                         digest = rte_pktmbuf_read(ut_params->ibuf,
6626                                 (tdata->digest.offset_bytes == 0 ?
6627                                 plaintext_pad_len : tdata->digest.offset_bytes),
6628                                 tdata->digest.len, digest_buffer);
6629
6630                 debug_hexdump(stdout, "digest:", digest,
6631                         tdata->digest.len);
6632                 debug_hexdump(stdout, "digest expected:",
6633                         tdata->digest.data, tdata->digest.len);
6634         }
6635
6636         /* Validate obuf */
6637         if (verify) {
6638                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6639                         plaintext,
6640                         tdata->plaintext.data,
6641                         tdata->plaintext.len >> 3,
6642                         "ZUC Plaintext data not as expected");
6643         } else {
6644                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6645                         ciphertext,
6646                         tdata->ciphertext.data,
6647                         tdata->validDataLenInBits.len,
6648                         "ZUC Ciphertext data not as expected");
6649
6650                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6651                         digest,
6652                         tdata->digest.data,
6653                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6654                         "ZUC Generated auth tag not as expected");
6655         }
6656         return 0;
6657 }
6658
6659 static int
6660 test_kasumi_encryption_test_case_1(void)
6661 {
6662         return test_kasumi_encryption(&kasumi_test_case_1);
6663 }
6664
6665 static int
6666 test_kasumi_encryption_test_case_1_sgl(void)
6667 {
6668         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6669 }
6670
6671 static int
6672 test_kasumi_encryption_test_case_1_oop(void)
6673 {
6674         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6675 }
6676
6677 static int
6678 test_kasumi_encryption_test_case_1_oop_sgl(void)
6679 {
6680         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6681 }
6682
6683 static int
6684 test_kasumi_encryption_test_case_2(void)
6685 {
6686         return test_kasumi_encryption(&kasumi_test_case_2);
6687 }
6688
6689 static int
6690 test_kasumi_encryption_test_case_3(void)
6691 {
6692         return test_kasumi_encryption(&kasumi_test_case_3);
6693 }
6694
6695 static int
6696 test_kasumi_encryption_test_case_4(void)
6697 {
6698         return test_kasumi_encryption(&kasumi_test_case_4);
6699 }
6700
6701 static int
6702 test_kasumi_encryption_test_case_5(void)
6703 {
6704         return test_kasumi_encryption(&kasumi_test_case_5);
6705 }
6706
6707 static int
6708 test_kasumi_decryption_test_case_1(void)
6709 {
6710         return test_kasumi_decryption(&kasumi_test_case_1);
6711 }
6712
6713 static int
6714 test_kasumi_decryption_test_case_1_oop(void)
6715 {
6716         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6717 }
6718
6719 static int
6720 test_kasumi_decryption_test_case_2(void)
6721 {
6722         return test_kasumi_decryption(&kasumi_test_case_2);
6723 }
6724
6725 static int
6726 test_kasumi_decryption_test_case_3(void)
6727 {
6728         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6729         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6730                 return TEST_SKIPPED;
6731         return test_kasumi_decryption(&kasumi_test_case_3);
6732 }
6733
6734 static int
6735 test_kasumi_decryption_test_case_4(void)
6736 {
6737         return test_kasumi_decryption(&kasumi_test_case_4);
6738 }
6739
6740 static int
6741 test_kasumi_decryption_test_case_5(void)
6742 {
6743         return test_kasumi_decryption(&kasumi_test_case_5);
6744 }
6745 static int
6746 test_snow3g_encryption_test_case_1(void)
6747 {
6748         return test_snow3g_encryption(&snow3g_test_case_1);
6749 }
6750
6751 static int
6752 test_snow3g_encryption_test_case_1_oop(void)
6753 {
6754         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6755 }
6756
6757 static int
6758 test_snow3g_encryption_test_case_1_oop_sgl(void)
6759 {
6760         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6761 }
6762
6763
6764 static int
6765 test_snow3g_encryption_test_case_1_offset_oop(void)
6766 {
6767         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6768 }
6769
6770 static int
6771 test_snow3g_encryption_test_case_2(void)
6772 {
6773         return test_snow3g_encryption(&snow3g_test_case_2);
6774 }
6775
6776 static int
6777 test_snow3g_encryption_test_case_3(void)
6778 {
6779         return test_snow3g_encryption(&snow3g_test_case_3);
6780 }
6781
6782 static int
6783 test_snow3g_encryption_test_case_4(void)
6784 {
6785         return test_snow3g_encryption(&snow3g_test_case_4);
6786 }
6787
6788 static int
6789 test_snow3g_encryption_test_case_5(void)
6790 {
6791         return test_snow3g_encryption(&snow3g_test_case_5);
6792 }
6793
6794 static int
6795 test_snow3g_decryption_test_case_1(void)
6796 {
6797         return test_snow3g_decryption(&snow3g_test_case_1);
6798 }
6799
6800 static int
6801 test_snow3g_decryption_test_case_1_oop(void)
6802 {
6803         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6804 }
6805
6806 static int
6807 test_snow3g_decryption_test_case_2(void)
6808 {
6809         return test_snow3g_decryption(&snow3g_test_case_2);
6810 }
6811
6812 static int
6813 test_snow3g_decryption_test_case_3(void)
6814 {
6815         return test_snow3g_decryption(&snow3g_test_case_3);
6816 }
6817
6818 static int
6819 test_snow3g_decryption_test_case_4(void)
6820 {
6821         return test_snow3g_decryption(&snow3g_test_case_4);
6822 }
6823
6824 static int
6825 test_snow3g_decryption_test_case_5(void)
6826 {
6827         return test_snow3g_decryption(&snow3g_test_case_5);
6828 }
6829
6830 /*
6831  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6832  * Pattern digest from snow3g_test_data must be allocated as
6833  * 4 last bytes in plaintext.
6834  */
6835 static void
6836 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6837                 struct snow3g_hash_test_data *output)
6838 {
6839         if ((pattern != NULL) && (output != NULL)) {
6840                 output->key.len = pattern->key.len;
6841
6842                 memcpy(output->key.data,
6843                 pattern->key.data, pattern->key.len);
6844
6845                 output->auth_iv.len = pattern->auth_iv.len;
6846
6847                 memcpy(output->auth_iv.data,
6848                 pattern->auth_iv.data, pattern->auth_iv.len);
6849
6850                 output->plaintext.len = pattern->plaintext.len;
6851
6852                 memcpy(output->plaintext.data,
6853                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6854
6855                 output->digest.len = pattern->digest.len;
6856
6857                 memcpy(output->digest.data,
6858                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6859                 pattern->digest.len);
6860
6861                 output->validAuthLenInBits.len =
6862                 pattern->validAuthLenInBits.len;
6863         }
6864 }
6865
6866 /*
6867  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6868  */
6869 static int
6870 test_snow3g_decryption_with_digest_test_case_1(void)
6871 {
6872         struct snow3g_hash_test_data snow3g_hash_data;
6873         struct rte_cryptodev_info dev_info;
6874         struct crypto_testsuite_params *ts_params = &testsuite_params;
6875
6876         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6877         uint64_t feat_flags = dev_info.feature_flags;
6878
6879         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6880                 printf("Device doesn't support encrypted digest operations.\n");
6881                 return TEST_SKIPPED;
6882         }
6883
6884         /*
6885          * Function prepare data for hash verification test case.
6886          * Digest is allocated in 4 last bytes in plaintext, pattern.
6887          */
6888         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6889
6890         return test_snow3g_decryption(&snow3g_test_case_7) &
6891                         test_snow3g_authentication_verify(&snow3g_hash_data);
6892 }
6893
6894 static int
6895 test_snow3g_cipher_auth_test_case_1(void)
6896 {
6897         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6898 }
6899
6900 static int
6901 test_snow3g_auth_cipher_test_case_1(void)
6902 {
6903         return test_snow3g_auth_cipher(
6904                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6905 }
6906
6907 static int
6908 test_snow3g_auth_cipher_test_case_2(void)
6909 {
6910         return test_snow3g_auth_cipher(
6911                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6912 }
6913
6914 static int
6915 test_snow3g_auth_cipher_test_case_2_oop(void)
6916 {
6917         return test_snow3g_auth_cipher(
6918                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6919 }
6920
6921 static int
6922 test_snow3g_auth_cipher_part_digest_enc(void)
6923 {
6924         return test_snow3g_auth_cipher(
6925                 &snow3g_auth_cipher_partial_digest_encryption,
6926                         IN_PLACE, 0);
6927 }
6928
6929 static int
6930 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6931 {
6932         return test_snow3g_auth_cipher(
6933                 &snow3g_auth_cipher_partial_digest_encryption,
6934                         OUT_OF_PLACE, 0);
6935 }
6936
6937 static int
6938 test_snow3g_auth_cipher_test_case_3_sgl(void)
6939 {
6940         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6941         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6942                 return TEST_SKIPPED;
6943         return test_snow3g_auth_cipher_sgl(
6944                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6945 }
6946
6947 static int
6948 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6949 {
6950         return test_snow3g_auth_cipher_sgl(
6951                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6952 }
6953
6954 static int
6955 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6956 {
6957         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6958         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6959                 return TEST_SKIPPED;
6960         return test_snow3g_auth_cipher_sgl(
6961                 &snow3g_auth_cipher_partial_digest_encryption,
6962                         IN_PLACE, 0);
6963 }
6964
6965 static int
6966 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6967 {
6968         return test_snow3g_auth_cipher_sgl(
6969                 &snow3g_auth_cipher_partial_digest_encryption,
6970                         OUT_OF_PLACE, 0);
6971 }
6972
6973 static int
6974 test_snow3g_auth_cipher_verify_test_case_1(void)
6975 {
6976         return test_snow3g_auth_cipher(
6977                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6978 }
6979
6980 static int
6981 test_snow3g_auth_cipher_verify_test_case_2(void)
6982 {
6983         return test_snow3g_auth_cipher(
6984                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6985 }
6986
6987 static int
6988 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6989 {
6990         return test_snow3g_auth_cipher(
6991                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6992 }
6993
6994 static int
6995 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6996 {
6997         return test_snow3g_auth_cipher(
6998                 &snow3g_auth_cipher_partial_digest_encryption,
6999                         IN_PLACE, 1);
7000 }
7001
7002 static int
7003 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
7004 {
7005         return test_snow3g_auth_cipher(
7006                 &snow3g_auth_cipher_partial_digest_encryption,
7007                         OUT_OF_PLACE, 1);
7008 }
7009
7010 static int
7011 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7012 {
7013         return test_snow3g_auth_cipher_sgl(
7014                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7015 }
7016
7017 static int
7018 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7019 {
7020         return test_snow3g_auth_cipher_sgl(
7021                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7022 }
7023
7024 static int
7025 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7026 {
7027         return test_snow3g_auth_cipher_sgl(
7028                 &snow3g_auth_cipher_partial_digest_encryption,
7029                         IN_PLACE, 1);
7030 }
7031
7032 static int
7033 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7034 {
7035         return test_snow3g_auth_cipher_sgl(
7036                 &snow3g_auth_cipher_partial_digest_encryption,
7037                         OUT_OF_PLACE, 1);
7038 }
7039
7040 static int
7041 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7042 {
7043         return test_snow3g_auth_cipher(
7044                 &snow3g_test_case_7, IN_PLACE, 0);
7045 }
7046
7047 static int
7048 test_kasumi_auth_cipher_test_case_1(void)
7049 {
7050         return test_kasumi_auth_cipher(
7051                 &kasumi_test_case_3, IN_PLACE, 0);
7052 }
7053
7054 static int
7055 test_kasumi_auth_cipher_test_case_2(void)
7056 {
7057         return test_kasumi_auth_cipher(
7058                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7059 }
7060
7061 static int
7062 test_kasumi_auth_cipher_test_case_2_oop(void)
7063 {
7064         return test_kasumi_auth_cipher(
7065                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7066 }
7067
7068 static int
7069 test_kasumi_auth_cipher_test_case_2_sgl(void)
7070 {
7071         return test_kasumi_auth_cipher_sgl(
7072                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7073 }
7074
7075 static int
7076 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7077 {
7078         return test_kasumi_auth_cipher_sgl(
7079                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7080 }
7081
7082 static int
7083 test_kasumi_auth_cipher_verify_test_case_1(void)
7084 {
7085         return test_kasumi_auth_cipher(
7086                 &kasumi_test_case_3, IN_PLACE, 1);
7087 }
7088
7089 static int
7090 test_kasumi_auth_cipher_verify_test_case_2(void)
7091 {
7092         return test_kasumi_auth_cipher(
7093                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7094 }
7095
7096 static int
7097 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7098 {
7099         return test_kasumi_auth_cipher(
7100                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7101 }
7102
7103 static int
7104 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7105 {
7106         return test_kasumi_auth_cipher_sgl(
7107                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7108 }
7109
7110 static int
7111 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7112 {
7113         return test_kasumi_auth_cipher_sgl(
7114                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7115 }
7116
7117 static int
7118 test_kasumi_cipher_auth_test_case_1(void)
7119 {
7120         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7121 }
7122
7123 static int
7124 test_zuc_encryption_test_case_1(void)
7125 {
7126         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7127 }
7128
7129 static int
7130 test_zuc_encryption_test_case_2(void)
7131 {
7132         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7133 }
7134
7135 static int
7136 test_zuc_encryption_test_case_3(void)
7137 {
7138         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7139 }
7140
7141 static int
7142 test_zuc_encryption_test_case_4(void)
7143 {
7144         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7145 }
7146
7147 static int
7148 test_zuc_encryption_test_case_5(void)
7149 {
7150         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7151 }
7152
7153 static int
7154 test_zuc_encryption_test_case_6_sgl(void)
7155 {
7156         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7157 }
7158
7159 static int
7160 test_zuc_hash_generate_test_case_1(void)
7161 {
7162         return test_zuc_authentication(&zuc_test_case_auth_1b);
7163 }
7164
7165 static int
7166 test_zuc_hash_generate_test_case_2(void)
7167 {
7168         return test_zuc_authentication(&zuc_test_case_auth_90b);
7169 }
7170
7171 static int
7172 test_zuc_hash_generate_test_case_3(void)
7173 {
7174         return test_zuc_authentication(&zuc_test_case_auth_577b);
7175 }
7176
7177 static int
7178 test_zuc_hash_generate_test_case_4(void)
7179 {
7180         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7181 }
7182
7183 static int
7184 test_zuc_hash_generate_test_case_5(void)
7185 {
7186         return test_zuc_authentication(&zuc_test_auth_5670b);
7187 }
7188
7189 static int
7190 test_zuc_hash_generate_test_case_6(void)
7191 {
7192         return test_zuc_authentication(&zuc_test_case_auth_128b);
7193 }
7194
7195 static int
7196 test_zuc_hash_generate_test_case_7(void)
7197 {
7198         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7199 }
7200
7201 static int
7202 test_zuc_hash_generate_test_case_8(void)
7203 {
7204         return test_zuc_authentication(&zuc_test_case_auth_584b);
7205 }
7206
7207 static int
7208 test_zuc_hash_generate_test_case_9(void)
7209 {
7210         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7211 }
7212
7213 static int
7214 test_zuc_hash_generate_test_case_10(void)
7215 {
7216         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7217 }
7218
7219 static int
7220 test_zuc_hash_generate_test_case_11(void)
7221 {
7222         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7223 }
7224
7225 static int
7226 test_zuc_cipher_auth_test_case_1(void)
7227 {
7228         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7229 }
7230
7231 static int
7232 test_zuc_cipher_auth_test_case_2(void)
7233 {
7234         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7235 }
7236
7237 static int
7238 test_zuc_auth_cipher_test_case_1(void)
7239 {
7240         return test_zuc_auth_cipher(
7241                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7242 }
7243
7244 static int
7245 test_zuc_auth_cipher_test_case_1_oop(void)
7246 {
7247         return test_zuc_auth_cipher(
7248                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7249 }
7250
7251 static int
7252 test_zuc_auth_cipher_test_case_1_sgl(void)
7253 {
7254         return test_zuc_auth_cipher_sgl(
7255                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7256 }
7257
7258 static int
7259 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7260 {
7261         return test_zuc_auth_cipher_sgl(
7262                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7263 }
7264
7265 static int
7266 test_zuc_auth_cipher_verify_test_case_1(void)
7267 {
7268         return test_zuc_auth_cipher(
7269                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7270 }
7271
7272 static int
7273 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7274 {
7275         return test_zuc_auth_cipher(
7276                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7277 }
7278
7279 static int
7280 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7281 {
7282         return test_zuc_auth_cipher_sgl(
7283                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7284 }
7285
7286 static int
7287 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7288 {
7289         return test_zuc_auth_cipher_sgl(
7290                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7291 }
7292
7293 static int
7294 test_zuc256_encryption_test_case_1(void)
7295 {
7296         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7297 }
7298
7299 static int
7300 test_zuc256_encryption_test_case_2(void)
7301 {
7302         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7303 }
7304
7305 static int
7306 test_zuc256_authentication_test_case_1(void)
7307 {
7308         return test_zuc_authentication(&zuc256_test_case_auth_1);
7309 }
7310
7311 static int
7312 test_zuc256_authentication_test_case_2(void)
7313 {
7314         return test_zuc_authentication(&zuc256_test_case_auth_2);
7315 }
7316
7317 static int
7318 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7319 {
7320         uint8_t dev_id = testsuite_params.valid_devs[0];
7321
7322         struct rte_cryptodev_sym_capability_idx cap_idx;
7323
7324         /* Check if device supports particular cipher algorithm */
7325         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7326         cap_idx.algo.cipher = tdata->cipher_algo;
7327         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7328                 return TEST_SKIPPED;
7329
7330         /* Check if device supports particular hash algorithm */
7331         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7332         cap_idx.algo.auth = tdata->auth_algo;
7333         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7334                 return TEST_SKIPPED;
7335
7336         return 0;
7337 }
7338
7339 static int
7340 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7341         uint8_t op_mode, uint8_t verify)
7342 {
7343         struct crypto_testsuite_params *ts_params = &testsuite_params;
7344         struct crypto_unittest_params *ut_params = &unittest_params;
7345
7346         int retval;
7347
7348         uint8_t *plaintext = NULL, *ciphertext = NULL;
7349         unsigned int plaintext_pad_len;
7350         unsigned int plaintext_len;
7351         unsigned int ciphertext_pad_len;
7352         unsigned int ciphertext_len;
7353
7354         struct rte_cryptodev_info dev_info;
7355         struct rte_crypto_op *op;
7356
7357         /* Check if device supports particular algorithms separately */
7358         if (test_mixed_check_if_unsupported(tdata))
7359                 return TEST_SKIPPED;
7360         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7361                 return TEST_SKIPPED;
7362
7363         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7364
7365         uint64_t feat_flags = dev_info.feature_flags;
7366
7367         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7368                 printf("Device doesn't support digest encrypted.\n");
7369                 return TEST_SKIPPED;
7370         }
7371
7372         /* Create the session */
7373         if (verify)
7374                 retval = create_wireless_algo_cipher_auth_session(
7375                                 ts_params->valid_devs[0],
7376                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7377                                 RTE_CRYPTO_AUTH_OP_VERIFY,
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         else
7384                 retval = create_wireless_algo_auth_cipher_session(
7385                                 ts_params->valid_devs[0],
7386                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7387                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7388                                 tdata->auth_algo,
7389                                 tdata->cipher_algo,
7390                                 tdata->auth_key.data, tdata->auth_key.len,
7391                                 tdata->auth_iv.len, tdata->digest_enc.len,
7392                                 tdata->cipher_iv.len);
7393         if (retval != 0)
7394                 return retval;
7395
7396         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7397         if (op_mode == OUT_OF_PLACE)
7398                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7399
7400         /* clear mbuf payload */
7401         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7402                 rte_pktmbuf_tailroom(ut_params->ibuf));
7403         if (op_mode == OUT_OF_PLACE) {
7404
7405                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7406                                 rte_pktmbuf_tailroom(ut_params->obuf));
7407         }
7408
7409         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7410         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7411         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7412         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7413
7414         if (verify) {
7415                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7416                                 ciphertext_pad_len);
7417                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7418                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7419                                 ciphertext_len);
7420         } else {
7421                 /* make sure enough space to cover partial digest verify case */
7422                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7423                                 ciphertext_pad_len);
7424                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7425                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7426         }
7427
7428         if (op_mode == OUT_OF_PLACE)
7429                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7430
7431         /* Create the operation */
7432         retval = create_wireless_algo_auth_cipher_operation(
7433                         tdata->digest_enc.data, tdata->digest_enc.len,
7434                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7435                         tdata->auth_iv.data, tdata->auth_iv.len,
7436                         (tdata->digest_enc.offset == 0 ?
7437                                 plaintext_pad_len
7438                                 : tdata->digest_enc.offset),
7439                         tdata->validCipherLen.len_bits,
7440                         tdata->cipher.offset_bits,
7441                         tdata->validAuthLen.len_bits,
7442                         tdata->auth.offset_bits,
7443                         op_mode, 0, verify);
7444
7445         if (retval < 0)
7446                 return retval;
7447
7448         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7449
7450         /* Check if the op failed because the device doesn't */
7451         /* support this particular combination of algorithms */
7452         if (op == NULL && ut_params->op->status ==
7453                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7454                 printf("Device doesn't support this mixed combination. "
7455                                 "Test Skipped.\n");
7456                 return TEST_SKIPPED;
7457         }
7458         ut_params->op = op;
7459
7460         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7461
7462         ut_params->obuf = (op_mode == IN_PLACE ?
7463                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7464
7465         if (verify) {
7466                 if (ut_params->obuf)
7467                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7468                                                         uint8_t *);
7469                 else
7470                         plaintext = ciphertext +
7471                                         (tdata->cipher.offset_bits >> 3);
7472
7473                 debug_hexdump(stdout, "plaintext:", plaintext,
7474                                 tdata->plaintext.len_bits >> 3);
7475                 debug_hexdump(stdout, "plaintext expected:",
7476                                 tdata->plaintext.data,
7477                                 tdata->plaintext.len_bits >> 3);
7478         } else {
7479                 if (ut_params->obuf)
7480                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7481                                         uint8_t *);
7482                 else
7483                         ciphertext = plaintext;
7484
7485                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7486                                 ciphertext_len);
7487                 debug_hexdump(stdout, "ciphertext expected:",
7488                                 tdata->ciphertext.data,
7489                                 tdata->ciphertext.len_bits >> 3);
7490
7491                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7492                                 + (tdata->digest_enc.offset == 0 ?
7493                 plaintext_pad_len : tdata->digest_enc.offset);
7494
7495                 debug_hexdump(stdout, "digest:", ut_params->digest,
7496                                 tdata->digest_enc.len);
7497                 debug_hexdump(stdout, "digest expected:",
7498                                 tdata->digest_enc.data,
7499                                 tdata->digest_enc.len);
7500         }
7501
7502         if (!verify) {
7503                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7504                                 ut_params->digest,
7505                                 tdata->digest_enc.data,
7506                                 tdata->digest_enc.len,
7507                                 "Generated auth tag not as expected");
7508         }
7509
7510         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7511                 if (verify) {
7512                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7513                                         plaintext,
7514                                         tdata->plaintext.data,
7515                                         tdata->plaintext.len_bits >> 3,
7516                                         "Plaintext data not as expected");
7517                 } else {
7518                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7519                                         ciphertext,
7520                                         tdata->ciphertext.data,
7521                                         tdata->validDataLen.len_bits,
7522                                         "Ciphertext data not as expected");
7523                 }
7524         }
7525
7526         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7527                         "crypto op processing failed");
7528
7529         return 0;
7530 }
7531
7532 static int
7533 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7534         uint8_t op_mode, uint8_t verify)
7535 {
7536         struct crypto_testsuite_params *ts_params = &testsuite_params;
7537         struct crypto_unittest_params *ut_params = &unittest_params;
7538
7539         int retval;
7540
7541         const uint8_t *plaintext = NULL;
7542         const uint8_t *ciphertext = NULL;
7543         const uint8_t *digest = NULL;
7544         unsigned int plaintext_pad_len;
7545         unsigned int plaintext_len;
7546         unsigned int ciphertext_pad_len;
7547         unsigned int ciphertext_len;
7548         uint8_t buffer[10000];
7549         uint8_t digest_buffer[10000];
7550
7551         struct rte_cryptodev_info dev_info;
7552         struct rte_crypto_op *op;
7553
7554         /* Check if device supports particular algorithms */
7555         if (test_mixed_check_if_unsupported(tdata))
7556                 return TEST_SKIPPED;
7557         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7558                 return TEST_SKIPPED;
7559
7560         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7561
7562         uint64_t feat_flags = dev_info.feature_flags;
7563
7564         if (op_mode == IN_PLACE) {
7565                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7566                         printf("Device doesn't support in-place scatter-gather "
7567                                         "in both input and output mbufs.\n");
7568                         return TEST_SKIPPED;
7569                 }
7570         } else {
7571                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7572                         printf("Device doesn't support out-of-place scatter-gather "
7573                                         "in both input and output mbufs.\n");
7574                         return TEST_SKIPPED;
7575                 }
7576                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7577                         printf("Device doesn't support digest encrypted.\n");
7578                         return TEST_SKIPPED;
7579                 }
7580         }
7581
7582         /* Create the session */
7583         if (verify)
7584                 retval = create_wireless_algo_cipher_auth_session(
7585                                 ts_params->valid_devs[0],
7586                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7587                                 RTE_CRYPTO_AUTH_OP_VERIFY,
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         else
7594                 retval = create_wireless_algo_auth_cipher_session(
7595                                 ts_params->valid_devs[0],
7596                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7597                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7598                                 tdata->auth_algo,
7599                                 tdata->cipher_algo,
7600                                 tdata->auth_key.data, tdata->auth_key.len,
7601                                 tdata->auth_iv.len, tdata->digest_enc.len,
7602                                 tdata->cipher_iv.len);
7603         if (retval != 0)
7604                 return retval;
7605
7606         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7607         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7608         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7609         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7610
7611         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7612                         ciphertext_pad_len, 15, 0);
7613         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7614                         "Failed to allocate input buffer in mempool");
7615
7616         if (op_mode == OUT_OF_PLACE) {
7617                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7618                                 plaintext_pad_len, 15, 0);
7619                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7620                                 "Failed to allocate output buffer in mempool");
7621         }
7622
7623         if (verify) {
7624                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7625                         tdata->ciphertext.data);
7626                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7627                                         ciphertext_len, buffer);
7628                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7629                         ciphertext_len);
7630         } else {
7631                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7632                         tdata->plaintext.data);
7633                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7634                                         plaintext_len, buffer);
7635                 debug_hexdump(stdout, "plaintext:", plaintext,
7636                         plaintext_len);
7637         }
7638         memset(buffer, 0, sizeof(buffer));
7639
7640         /* Create the operation */
7641         retval = create_wireless_algo_auth_cipher_operation(
7642                         tdata->digest_enc.data, tdata->digest_enc.len,
7643                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7644                         tdata->auth_iv.data, tdata->auth_iv.len,
7645                         (tdata->digest_enc.offset == 0 ?
7646                                 plaintext_pad_len
7647                                 : tdata->digest_enc.offset),
7648                         tdata->validCipherLen.len_bits,
7649                         tdata->cipher.offset_bits,
7650                         tdata->validAuthLen.len_bits,
7651                         tdata->auth.offset_bits,
7652                         op_mode, 1, verify);
7653
7654         if (retval < 0)
7655                 return retval;
7656
7657         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7658
7659         /* Check if the op failed because the device doesn't */
7660         /* support this particular combination of algorithms */
7661         if (op == NULL && ut_params->op->status ==
7662                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7663                 printf("Device doesn't support this mixed combination. "
7664                                 "Test Skipped.\n");
7665                 return TEST_SKIPPED;
7666         }
7667         ut_params->op = op;
7668
7669         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7670
7671         ut_params->obuf = (op_mode == IN_PLACE ?
7672                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7673
7674         if (verify) {
7675                 if (ut_params->obuf)
7676                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7677                                         plaintext_len, buffer);
7678                 else
7679                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7680                                         plaintext_len, buffer);
7681
7682                 debug_hexdump(stdout, "plaintext:", plaintext,
7683                                 (tdata->plaintext.len_bits >> 3) -
7684                                 tdata->digest_enc.len);
7685                 debug_hexdump(stdout, "plaintext expected:",
7686                                 tdata->plaintext.data,
7687                                 (tdata->plaintext.len_bits >> 3) -
7688                                 tdata->digest_enc.len);
7689         } else {
7690                 if (ut_params->obuf)
7691                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7692                                         ciphertext_len, buffer);
7693                 else
7694                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7695                                         ciphertext_len, buffer);
7696
7697                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7698                         ciphertext_len);
7699                 debug_hexdump(stdout, "ciphertext expected:",
7700                         tdata->ciphertext.data,
7701                         tdata->ciphertext.len_bits >> 3);
7702
7703                 if (ut_params->obuf)
7704                         digest = rte_pktmbuf_read(ut_params->obuf,
7705                                         (tdata->digest_enc.offset == 0 ?
7706                                                 plaintext_pad_len :
7707                                                 tdata->digest_enc.offset),
7708                                         tdata->digest_enc.len, digest_buffer);
7709                 else
7710                         digest = rte_pktmbuf_read(ut_params->ibuf,
7711                                         (tdata->digest_enc.offset == 0 ?
7712                                                 plaintext_pad_len :
7713                                                 tdata->digest_enc.offset),
7714                                         tdata->digest_enc.len, digest_buffer);
7715
7716                 debug_hexdump(stdout, "digest:", digest,
7717                                 tdata->digest_enc.len);
7718                 debug_hexdump(stdout, "digest expected:",
7719                                 tdata->digest_enc.data, tdata->digest_enc.len);
7720         }
7721
7722         if (!verify) {
7723                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7724                                 digest,
7725                                 tdata->digest_enc.data,
7726                                 tdata->digest_enc.len,
7727                                 "Generated auth tag not as expected");
7728         }
7729
7730         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7731                 if (verify) {
7732                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7733                                         plaintext,
7734                                         tdata->plaintext.data,
7735                                         tdata->plaintext.len_bits >> 3,
7736                                         "Plaintext data not as expected");
7737                 } else {
7738                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7739                                         ciphertext,
7740                                         tdata->ciphertext.data,
7741                                         tdata->validDataLen.len_bits,
7742                                         "Ciphertext data not as expected");
7743                 }
7744         }
7745
7746         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7747                         "crypto op processing failed");
7748
7749         return 0;
7750 }
7751
7752 /** AUTH AES CMAC + CIPHER AES CTR */
7753
7754 static int
7755 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7756 {
7757         return test_mixed_auth_cipher(
7758                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7759 }
7760
7761 static int
7762 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7763 {
7764         return test_mixed_auth_cipher(
7765                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7766 }
7767
7768 static int
7769 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7770 {
7771         return test_mixed_auth_cipher_sgl(
7772                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7773 }
7774
7775 static int
7776 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7777 {
7778         return test_mixed_auth_cipher_sgl(
7779                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7780 }
7781
7782 static int
7783 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7784 {
7785         return test_mixed_auth_cipher(
7786                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7787 }
7788
7789 static int
7790 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7791 {
7792         return test_mixed_auth_cipher(
7793                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7794 }
7795
7796 static int
7797 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7798 {
7799         return test_mixed_auth_cipher_sgl(
7800                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7801 }
7802
7803 static int
7804 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7805 {
7806         return test_mixed_auth_cipher_sgl(
7807                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7808 }
7809
7810 /** MIXED AUTH + CIPHER */
7811
7812 static int
7813 test_auth_zuc_cipher_snow_test_case_1(void)
7814 {
7815         return test_mixed_auth_cipher(
7816                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7817 }
7818
7819 static int
7820 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7821 {
7822         return test_mixed_auth_cipher(
7823                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7824 }
7825
7826 static int
7827 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7828 {
7829         return test_mixed_auth_cipher(
7830                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7831 }
7832
7833 static int
7834 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7835 {
7836         return test_mixed_auth_cipher(
7837                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7838 }
7839
7840 static int
7841 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7842 {
7843         return test_mixed_auth_cipher(
7844                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7845 }
7846
7847 static int
7848 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7849 {
7850         return test_mixed_auth_cipher(
7851                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7852 }
7853
7854 static int
7855 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7856 {
7857         return test_mixed_auth_cipher(
7858                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7859 }
7860
7861 static int
7862 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7863 {
7864         return test_mixed_auth_cipher(
7865                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7866 }
7867
7868 static int
7869 test_auth_snow_cipher_zuc_test_case_1(void)
7870 {
7871         return test_mixed_auth_cipher(
7872                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7873 }
7874
7875 static int
7876 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7877 {
7878         return test_mixed_auth_cipher(
7879                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7880 }
7881
7882 static int
7883 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7884 {
7885         return test_mixed_auth_cipher(
7886                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7887 }
7888
7889 static int
7890 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7891 {
7892         return test_mixed_auth_cipher(
7893                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7894 }
7895
7896 static int
7897 test_auth_null_cipher_snow_test_case_1(void)
7898 {
7899         return test_mixed_auth_cipher(
7900                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7901 }
7902
7903 static int
7904 test_verify_auth_null_cipher_snow_test_case_1(void)
7905 {
7906         return test_mixed_auth_cipher(
7907                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7908 }
7909
7910 static int
7911 test_auth_null_cipher_zuc_test_case_1(void)
7912 {
7913         return test_mixed_auth_cipher(
7914                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7915 }
7916
7917 static int
7918 test_verify_auth_null_cipher_zuc_test_case_1(void)
7919 {
7920         return test_mixed_auth_cipher(
7921                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7922 }
7923
7924 static int
7925 test_auth_snow_cipher_null_test_case_1(void)
7926 {
7927         return test_mixed_auth_cipher(
7928                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7929 }
7930
7931 static int
7932 test_verify_auth_snow_cipher_null_test_case_1(void)
7933 {
7934         return test_mixed_auth_cipher(
7935                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7936 }
7937
7938 static int
7939 test_auth_zuc_cipher_null_test_case_1(void)
7940 {
7941         return test_mixed_auth_cipher(
7942                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7943 }
7944
7945 static int
7946 test_verify_auth_zuc_cipher_null_test_case_1(void)
7947 {
7948         return test_mixed_auth_cipher(
7949                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7950 }
7951
7952 static int
7953 test_auth_null_cipher_aes_ctr_test_case_1(void)
7954 {
7955         return test_mixed_auth_cipher(
7956                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7957 }
7958
7959 static int
7960 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7961 {
7962         return test_mixed_auth_cipher(
7963                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7964 }
7965
7966 static int
7967 test_auth_aes_cmac_cipher_null_test_case_1(void)
7968 {
7969         return test_mixed_auth_cipher(
7970                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7971 }
7972
7973 static int
7974 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7975 {
7976         return test_mixed_auth_cipher(
7977                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7978 }
7979
7980 /* ***** AEAD algorithm Tests ***** */
7981
7982 static int
7983 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7984                 enum rte_crypto_aead_operation op,
7985                 const uint8_t *key, const uint8_t key_len,
7986                 const uint16_t aad_len, const uint8_t auth_len,
7987                 uint8_t iv_len)
7988 {
7989         uint8_t aead_key[key_len];
7990         int status;
7991
7992         struct crypto_testsuite_params *ts_params = &testsuite_params;
7993         struct crypto_unittest_params *ut_params = &unittest_params;
7994
7995         memcpy(aead_key, key, key_len);
7996
7997         /* Setup AEAD Parameters */
7998         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7999         ut_params->aead_xform.next = NULL;
8000         ut_params->aead_xform.aead.algo = algo;
8001         ut_params->aead_xform.aead.op = op;
8002         ut_params->aead_xform.aead.key.data = aead_key;
8003         ut_params->aead_xform.aead.key.length = key_len;
8004         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8005         ut_params->aead_xform.aead.iv.length = iv_len;
8006         ut_params->aead_xform.aead.digest_length = auth_len;
8007         ut_params->aead_xform.aead.aad_length = aad_len;
8008
8009         debug_hexdump(stdout, "key:", key, key_len);
8010
8011         /* Create Crypto session*/
8012         ut_params->sess = rte_cryptodev_sym_session_create(
8013                         ts_params->session_mpool);
8014         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8015
8016         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8017                         &ut_params->aead_xform,
8018                         ts_params->session_priv_mpool);
8019
8020         return status;
8021 }
8022
8023 static int
8024 create_aead_xform(struct rte_crypto_op *op,
8025                 enum rte_crypto_aead_algorithm algo,
8026                 enum rte_crypto_aead_operation aead_op,
8027                 uint8_t *key, const uint8_t key_len,
8028                 const uint8_t aad_len, const uint8_t auth_len,
8029                 uint8_t iv_len)
8030 {
8031         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8032                         "failed to allocate space for crypto transform");
8033
8034         struct rte_crypto_sym_op *sym_op = op->sym;
8035
8036         /* Setup AEAD Parameters */
8037         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8038         sym_op->xform->next = NULL;
8039         sym_op->xform->aead.algo = algo;
8040         sym_op->xform->aead.op = aead_op;
8041         sym_op->xform->aead.key.data = key;
8042         sym_op->xform->aead.key.length = key_len;
8043         sym_op->xform->aead.iv.offset = IV_OFFSET;
8044         sym_op->xform->aead.iv.length = iv_len;
8045         sym_op->xform->aead.digest_length = auth_len;
8046         sym_op->xform->aead.aad_length = aad_len;
8047
8048         debug_hexdump(stdout, "key:", key, key_len);
8049
8050         return 0;
8051 }
8052
8053 static int
8054 create_aead_operation(enum rte_crypto_aead_operation op,
8055                 const struct aead_test_data *tdata)
8056 {
8057         struct crypto_testsuite_params *ts_params = &testsuite_params;
8058         struct crypto_unittest_params *ut_params = &unittest_params;
8059
8060         uint8_t *plaintext, *ciphertext;
8061         unsigned int aad_pad_len, plaintext_pad_len;
8062
8063         /* Generate Crypto op data structure */
8064         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8065                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8066         TEST_ASSERT_NOT_NULL(ut_params->op,
8067                         "Failed to allocate symmetric crypto operation struct");
8068
8069         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8070
8071         /* Append aad data */
8072         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8073                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8074                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8075                                 aad_pad_len);
8076                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8077                                 "no room to append aad");
8078
8079                 sym_op->aead.aad.phys_addr =
8080                                 rte_pktmbuf_iova(ut_params->ibuf);
8081                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8082                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8083                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8084                         tdata->aad.len);
8085
8086                 /* Append IV at the end of the crypto operation*/
8087                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8088                                 uint8_t *, IV_OFFSET);
8089
8090                 /* Copy IV 1 byte after the IV pointer, according to the API */
8091                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8092                 debug_hexdump(stdout, "iv:", iv_ptr,
8093                         tdata->iv.len);
8094         } else {
8095                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8096                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8097                                 aad_pad_len);
8098                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8099                                 "no room to append aad");
8100
8101                 sym_op->aead.aad.phys_addr =
8102                                 rte_pktmbuf_iova(ut_params->ibuf);
8103                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8104                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8105                         tdata->aad.len);
8106
8107                 /* Append IV at the end of the crypto operation*/
8108                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8109                                 uint8_t *, IV_OFFSET);
8110
8111                 if (tdata->iv.len == 0) {
8112                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8113                         debug_hexdump(stdout, "iv:", iv_ptr,
8114                                 AES_GCM_J0_LENGTH);
8115                 } else {
8116                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8117                         debug_hexdump(stdout, "iv:", iv_ptr,
8118                                 tdata->iv.len);
8119                 }
8120         }
8121
8122         /* Append plaintext/ciphertext */
8123         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8124                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8125                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8126                                 plaintext_pad_len);
8127                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8128
8129                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8130                 debug_hexdump(stdout, "plaintext:", plaintext,
8131                                 tdata->plaintext.len);
8132
8133                 if (ut_params->obuf) {
8134                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8135                                         ut_params->obuf,
8136                                         plaintext_pad_len + aad_pad_len);
8137                         TEST_ASSERT_NOT_NULL(ciphertext,
8138                                         "no room to append ciphertext");
8139
8140                         memset(ciphertext + aad_pad_len, 0,
8141                                         tdata->ciphertext.len);
8142                 }
8143         } else {
8144                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8145                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8146                                 plaintext_pad_len);
8147                 TEST_ASSERT_NOT_NULL(ciphertext,
8148                                 "no room to append ciphertext");
8149
8150                 memcpy(ciphertext, tdata->ciphertext.data,
8151                                 tdata->ciphertext.len);
8152                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8153                                 tdata->ciphertext.len);
8154
8155                 if (ut_params->obuf) {
8156                         plaintext = (uint8_t *)rte_pktmbuf_append(
8157                                         ut_params->obuf,
8158                                         plaintext_pad_len + aad_pad_len);
8159                         TEST_ASSERT_NOT_NULL(plaintext,
8160                                         "no room to append plaintext");
8161
8162                         memset(plaintext + aad_pad_len, 0,
8163                                         tdata->plaintext.len);
8164                 }
8165         }
8166
8167         /* Append digest data */
8168         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8169                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8170                                 ut_params->obuf ? ut_params->obuf :
8171                                                 ut_params->ibuf,
8172                                                 tdata->auth_tag.len);
8173                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8174                                 "no room to append digest");
8175                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8176                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8177                                 ut_params->obuf ? ut_params->obuf :
8178                                                 ut_params->ibuf,
8179                                                 plaintext_pad_len +
8180                                                 aad_pad_len);
8181         } else {
8182                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8183                                 ut_params->ibuf, tdata->auth_tag.len);
8184                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8185                                 "no room to append digest");
8186                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8187                                 ut_params->ibuf,
8188                                 plaintext_pad_len + aad_pad_len);
8189
8190                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8191                         tdata->auth_tag.len);
8192                 debug_hexdump(stdout, "digest:",
8193                         sym_op->aead.digest.data,
8194                         tdata->auth_tag.len);
8195         }
8196
8197         sym_op->aead.data.length = tdata->plaintext.len;
8198         sym_op->aead.data.offset = aad_pad_len;
8199
8200         return 0;
8201 }
8202
8203 static int
8204 test_authenticated_encryption(const struct aead_test_data *tdata)
8205 {
8206         struct crypto_testsuite_params *ts_params = &testsuite_params;
8207         struct crypto_unittest_params *ut_params = &unittest_params;
8208
8209         int retval;
8210         uint8_t *ciphertext, *auth_tag;
8211         uint16_t plaintext_pad_len;
8212         uint32_t i;
8213         struct rte_cryptodev_info dev_info;
8214
8215         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8216         uint64_t feat_flags = dev_info.feature_flags;
8217
8218         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8219                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8220                 printf("Device doesn't support RAW data-path APIs.\n");
8221                 return TEST_SKIPPED;
8222         }
8223
8224         /* Verify the capabilities */
8225         struct rte_cryptodev_sym_capability_idx cap_idx;
8226         const struct rte_cryptodev_symmetric_capability *capability;
8227         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8228         cap_idx.algo.aead = tdata->algo;
8229         capability = rte_cryptodev_sym_capability_get(
8230                         ts_params->valid_devs[0], &cap_idx);
8231         if (capability == NULL)
8232                 return TEST_SKIPPED;
8233         if (rte_cryptodev_sym_capability_check_aead(
8234                         capability, tdata->key.len, tdata->auth_tag.len,
8235                         tdata->aad.len, tdata->iv.len))
8236                 return TEST_SKIPPED;
8237
8238         /* Create AEAD session */
8239         retval = create_aead_session(ts_params->valid_devs[0],
8240                         tdata->algo,
8241                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8242                         tdata->key.data, tdata->key.len,
8243                         tdata->aad.len, tdata->auth_tag.len,
8244                         tdata->iv.len);
8245         if (retval < 0)
8246                 return retval;
8247
8248         if (tdata->aad.len > MBUF_SIZE) {
8249                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8250                 /* Populate full size of add data */
8251                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8252                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8253         } else
8254                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8255
8256         /* clear mbuf payload */
8257         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8258                         rte_pktmbuf_tailroom(ut_params->ibuf));
8259
8260         /* Create AEAD operation */
8261         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8262         if (retval < 0)
8263                 return retval;
8264
8265         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8266
8267         ut_params->op->sym->m_src = ut_params->ibuf;
8268
8269         /* Process crypto operation */
8270         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8271                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8272         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8273                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8274                                 ut_params->op, 0, 0, 0, 0);
8275         else
8276                 TEST_ASSERT_NOT_NULL(
8277                         process_crypto_request(ts_params->valid_devs[0],
8278                         ut_params->op), "failed to process sym crypto op");
8279
8280         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8281                         "crypto op processing failed");
8282
8283         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8284
8285         if (ut_params->op->sym->m_dst) {
8286                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8287                                 uint8_t *);
8288                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8289                                 uint8_t *, plaintext_pad_len);
8290         } else {
8291                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8292                                 uint8_t *,
8293                                 ut_params->op->sym->cipher.data.offset);
8294                 auth_tag = ciphertext + plaintext_pad_len;
8295         }
8296
8297         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8298         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8299
8300         /* Validate obuf */
8301         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8302                         ciphertext,
8303                         tdata->ciphertext.data,
8304                         tdata->ciphertext.len,
8305                         "Ciphertext data not as expected");
8306
8307         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8308                         auth_tag,
8309                         tdata->auth_tag.data,
8310                         tdata->auth_tag.len,
8311                         "Generated auth tag not as expected");
8312
8313         return 0;
8314
8315 }
8316
8317 #ifdef RTE_LIB_SECURITY
8318 static int
8319 security_proto_supported(enum rte_security_session_action_type action,
8320         enum rte_security_session_protocol proto)
8321 {
8322         struct crypto_testsuite_params *ts_params = &testsuite_params;
8323
8324         const struct rte_security_capability *capabilities;
8325         const struct rte_security_capability *capability;
8326         uint16_t i = 0;
8327
8328         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8329                                 rte_cryptodev_get_sec_ctx(
8330                                 ts_params->valid_devs[0]);
8331
8332
8333         capabilities = rte_security_capabilities_get(ctx);
8334
8335         if (capabilities == NULL)
8336                 return -ENOTSUP;
8337
8338         while ((capability = &capabilities[i++])->action !=
8339                         RTE_SECURITY_ACTION_TYPE_NONE) {
8340                 if (capability->action == action &&
8341                                 capability->protocol == proto)
8342                         return 0;
8343         }
8344
8345         return -ENOTSUP;
8346 }
8347
8348 /* Basic algorithm run function for async inplace mode.
8349  * Creates a session from input parameters and runs one operation
8350  * on input_vec. Checks the output of the crypto operation against
8351  * output_vec.
8352  */
8353 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8354                            enum rte_crypto_auth_operation opa,
8355                            const uint8_t *input_vec, unsigned int input_vec_len,
8356                            const uint8_t *output_vec,
8357                            unsigned int output_vec_len,
8358                            enum rte_crypto_cipher_algorithm cipher_alg,
8359                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8360                            enum rte_crypto_auth_algorithm auth_alg,
8361                            const uint8_t *auth_key, uint32_t auth_key_len,
8362                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8363                            uint8_t packet_direction, uint8_t sn_size,
8364                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8365 {
8366         struct crypto_testsuite_params *ts_params = &testsuite_params;
8367         struct crypto_unittest_params *ut_params = &unittest_params;
8368         uint8_t *plaintext;
8369         int ret = TEST_SUCCESS;
8370         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8371                                 rte_cryptodev_get_sec_ctx(
8372                                 ts_params->valid_devs[0]);
8373
8374         /* Verify the capabilities */
8375         struct rte_security_capability_idx sec_cap_idx;
8376
8377         sec_cap_idx.action = ut_params->type;
8378         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8379         sec_cap_idx.pdcp.domain = domain;
8380         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8381                 return TEST_SKIPPED;
8382
8383         /* Generate test mbuf data */
8384         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8385
8386         /* clear mbuf payload */
8387         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8388                         rte_pktmbuf_tailroom(ut_params->ibuf));
8389
8390         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8391                                                   input_vec_len);
8392         memcpy(plaintext, input_vec, input_vec_len);
8393
8394         /* Out of place support */
8395         if (oop) {
8396                 /*
8397                  * For out-op-place we need to alloc another mbuf
8398                  */
8399                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8400                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8401         }
8402
8403         /* Setup Cipher Parameters */
8404         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8405         ut_params->cipher_xform.cipher.algo = cipher_alg;
8406         ut_params->cipher_xform.cipher.op = opc;
8407         ut_params->cipher_xform.cipher.key.data = cipher_key;
8408         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8409         ut_params->cipher_xform.cipher.iv.length =
8410                                 packet_direction ? 4 : 0;
8411         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8412
8413         /* Setup HMAC Parameters if ICV header is required */
8414         if (auth_alg != 0) {
8415                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8416                 ut_params->auth_xform.next = NULL;
8417                 ut_params->auth_xform.auth.algo = auth_alg;
8418                 ut_params->auth_xform.auth.op = opa;
8419                 ut_params->auth_xform.auth.key.data = auth_key;
8420                 ut_params->auth_xform.auth.key.length = auth_key_len;
8421
8422                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8423         } else {
8424                 ut_params->cipher_xform.next = NULL;
8425         }
8426
8427         struct rte_security_session_conf sess_conf = {
8428                 .action_type = ut_params->type,
8429                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8430                 {.pdcp = {
8431                         .bearer = bearer,
8432                         .domain = domain,
8433                         .pkt_dir = packet_direction,
8434                         .sn_size = sn_size,
8435                         .hfn = packet_direction ? 0 : hfn,
8436                         /**
8437                          * hfn can be set as pdcp_test_hfn[i]
8438                          * if hfn_ovrd is not set. Here, PDCP
8439                          * packet direction is just used to
8440                          * run half of the cases with session
8441                          * HFN and other half with per packet
8442                          * HFN.
8443                          */
8444                         .hfn_threshold = hfn_threshold,
8445                         .hfn_ovrd = packet_direction ? 1 : 0,
8446                         .sdap_enabled = sdap,
8447                 } },
8448                 .crypto_xform = &ut_params->cipher_xform
8449         };
8450
8451         /* Create security session */
8452         ut_params->sec_session = rte_security_session_create(ctx,
8453                                 &sess_conf, ts_params->session_mpool,
8454                                 ts_params->session_priv_mpool);
8455
8456         if (!ut_params->sec_session) {
8457                 printf("TestCase %s()-%d line %d failed %s: ",
8458                         __func__, i, __LINE__, "Failed to allocate session");
8459                 ret = TEST_FAILED;
8460                 goto on_err;
8461         }
8462
8463         /* Generate crypto op data structure */
8464         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8465                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8466         if (!ut_params->op) {
8467                 printf("TestCase %s()-%d line %d failed %s: ",
8468                         __func__, i, __LINE__,
8469                         "Failed to allocate symmetric crypto operation struct");
8470                 ret = TEST_FAILED;
8471                 goto on_err;
8472         }
8473
8474         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8475                                         uint32_t *, IV_OFFSET);
8476         *per_pkt_hfn = packet_direction ? hfn : 0;
8477
8478         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8479
8480         /* set crypto operation source mbuf */
8481         ut_params->op->sym->m_src = ut_params->ibuf;
8482         if (oop)
8483                 ut_params->op->sym->m_dst = ut_params->obuf;
8484
8485         /* Process crypto operation */
8486         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8487                 == NULL) {
8488                 printf("TestCase %s()-%d line %d failed %s: ",
8489                         __func__, i, __LINE__,
8490                         "failed to process sym crypto op");
8491                 ret = TEST_FAILED;
8492                 goto on_err;
8493         }
8494
8495         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8496                 printf("TestCase %s()-%d line %d failed %s: ",
8497                         __func__, i, __LINE__, "crypto op processing failed");
8498                 ret = TEST_FAILED;
8499                 goto on_err;
8500         }
8501
8502         /* Validate obuf */
8503         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8504                         uint8_t *);
8505         if (oop) {
8506                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8507                                 uint8_t *);
8508         }
8509
8510         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8511                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8512                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8513                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8514                 ret = TEST_FAILED;
8515                 goto on_err;
8516         }
8517
8518 on_err:
8519         rte_crypto_op_free(ut_params->op);
8520         ut_params->op = NULL;
8521
8522         if (ut_params->sec_session)
8523                 rte_security_session_destroy(ctx, ut_params->sec_session);
8524         ut_params->sec_session = NULL;
8525
8526         rte_pktmbuf_free(ut_params->ibuf);
8527         ut_params->ibuf = NULL;
8528         if (oop) {
8529                 rte_pktmbuf_free(ut_params->obuf);
8530                 ut_params->obuf = NULL;
8531         }
8532
8533         return ret;
8534 }
8535
8536 static int
8537 test_pdcp_proto_SGL(int i, int oop,
8538         enum rte_crypto_cipher_operation opc,
8539         enum rte_crypto_auth_operation opa,
8540         uint8_t *input_vec,
8541         unsigned int input_vec_len,
8542         uint8_t *output_vec,
8543         unsigned int output_vec_len,
8544         uint32_t fragsz,
8545         uint32_t fragsz_oop)
8546 {
8547         struct crypto_testsuite_params *ts_params = &testsuite_params;
8548         struct crypto_unittest_params *ut_params = &unittest_params;
8549         uint8_t *plaintext;
8550         struct rte_mbuf *buf, *buf_oop = NULL;
8551         int ret = TEST_SUCCESS;
8552         int to_trn = 0;
8553         int to_trn_tbl[16];
8554         int segs = 1;
8555         unsigned int trn_data = 0;
8556         struct rte_cryptodev_info dev_info;
8557         uint64_t feat_flags;
8558         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8559                                 rte_cryptodev_get_sec_ctx(
8560                                 ts_params->valid_devs[0]);
8561         struct rte_mbuf *temp_mbuf;
8562
8563         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8564         feat_flags = dev_info.feature_flags;
8565
8566         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8567                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8568                 printf("Device does not support RAW data-path APIs.\n");
8569                 return -ENOTSUP;
8570         }
8571         /* Verify the capabilities */
8572         struct rte_security_capability_idx sec_cap_idx;
8573
8574         sec_cap_idx.action = ut_params->type;
8575         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8576         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8577         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8578                 return TEST_SKIPPED;
8579
8580         if (fragsz > input_vec_len)
8581                 fragsz = input_vec_len;
8582
8583         uint16_t plaintext_len = fragsz;
8584         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8585
8586         if (fragsz_oop > output_vec_len)
8587                 frag_size_oop = output_vec_len;
8588
8589         int ecx = 0;
8590         if (input_vec_len % fragsz != 0) {
8591                 if (input_vec_len / fragsz + 1 > 16)
8592                         return 1;
8593         } else if (input_vec_len / fragsz > 16)
8594                 return 1;
8595
8596         /* Out of place support */
8597         if (oop) {
8598                 /*
8599                  * For out-op-place we need to alloc another mbuf
8600                  */
8601                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8602                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8603                 buf_oop = ut_params->obuf;
8604         }
8605
8606         /* Generate test mbuf data */
8607         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8608
8609         /* clear mbuf payload */
8610         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8611                         rte_pktmbuf_tailroom(ut_params->ibuf));
8612
8613         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8614                                                   plaintext_len);
8615         memcpy(plaintext, input_vec, plaintext_len);
8616         trn_data += plaintext_len;
8617
8618         buf = ut_params->ibuf;
8619
8620         /*
8621          * Loop until no more fragments
8622          */
8623
8624         while (trn_data < input_vec_len) {
8625                 ++segs;
8626                 to_trn = (input_vec_len - trn_data < fragsz) ?
8627                                 (input_vec_len - trn_data) : fragsz;
8628
8629                 to_trn_tbl[ecx++] = to_trn;
8630
8631                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8632                 buf = buf->next;
8633
8634                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8635                                 rte_pktmbuf_tailroom(buf));
8636
8637                 /* OOP */
8638                 if (oop && !fragsz_oop) {
8639                         buf_oop->next =
8640                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8641                         buf_oop = buf_oop->next;
8642                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8643                                         0, rte_pktmbuf_tailroom(buf_oop));
8644                         rte_pktmbuf_append(buf_oop, to_trn);
8645                 }
8646
8647                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8648                                 to_trn);
8649
8650                 memcpy(plaintext, input_vec + trn_data, to_trn);
8651                 trn_data += to_trn;
8652         }
8653
8654         ut_params->ibuf->nb_segs = segs;
8655
8656         segs = 1;
8657         if (fragsz_oop && oop) {
8658                 to_trn = 0;
8659                 ecx = 0;
8660
8661                 trn_data = frag_size_oop;
8662                 while (trn_data < output_vec_len) {
8663                         ++segs;
8664                         to_trn =
8665                                 (output_vec_len - trn_data <
8666                                                 frag_size_oop) ?
8667                                 (output_vec_len - trn_data) :
8668                                                 frag_size_oop;
8669
8670                         to_trn_tbl[ecx++] = to_trn;
8671
8672                         buf_oop->next =
8673                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8674                         buf_oop = buf_oop->next;
8675                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8676                                         0, rte_pktmbuf_tailroom(buf_oop));
8677                         rte_pktmbuf_append(buf_oop, to_trn);
8678
8679                         trn_data += to_trn;
8680                 }
8681                 ut_params->obuf->nb_segs = segs;
8682         }
8683
8684         /* Setup Cipher Parameters */
8685         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8686         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8687         ut_params->cipher_xform.cipher.op = opc;
8688         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8689         ut_params->cipher_xform.cipher.key.length =
8690                                         pdcp_test_params[i].cipher_key_len;
8691         ut_params->cipher_xform.cipher.iv.length = 0;
8692
8693         /* Setup HMAC Parameters if ICV header is required */
8694         if (pdcp_test_params[i].auth_alg != 0) {
8695                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8696                 ut_params->auth_xform.next = NULL;
8697                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8698                 ut_params->auth_xform.auth.op = opa;
8699                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8700                 ut_params->auth_xform.auth.key.length =
8701                                         pdcp_test_params[i].auth_key_len;
8702
8703                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8704         } else {
8705                 ut_params->cipher_xform.next = NULL;
8706         }
8707
8708         struct rte_security_session_conf sess_conf = {
8709                 .action_type = ut_params->type,
8710                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8711                 {.pdcp = {
8712                         .bearer = pdcp_test_bearer[i],
8713                         .domain = pdcp_test_params[i].domain,
8714                         .pkt_dir = pdcp_test_packet_direction[i],
8715                         .sn_size = pdcp_test_data_sn_size[i],
8716                         .hfn = pdcp_test_hfn[i],
8717                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8718                         .hfn_ovrd = 0,
8719                 } },
8720                 .crypto_xform = &ut_params->cipher_xform
8721         };
8722
8723         /* Create security session */
8724         ut_params->sec_session = rte_security_session_create(ctx,
8725                                 &sess_conf, ts_params->session_mpool,
8726                                 ts_params->session_priv_mpool);
8727
8728         if (!ut_params->sec_session) {
8729                 printf("TestCase %s()-%d line %d failed %s: ",
8730                         __func__, i, __LINE__, "Failed to allocate session");
8731                 ret = TEST_FAILED;
8732                 goto on_err;
8733         }
8734
8735         /* Generate crypto op data structure */
8736         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8737                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8738         if (!ut_params->op) {
8739                 printf("TestCase %s()-%d line %d failed %s: ",
8740                         __func__, i, __LINE__,
8741                         "Failed to allocate symmetric crypto operation struct");
8742                 ret = TEST_FAILED;
8743                 goto on_err;
8744         }
8745
8746         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8747
8748         /* set crypto operation source mbuf */
8749         ut_params->op->sym->m_src = ut_params->ibuf;
8750         if (oop)
8751                 ut_params->op->sym->m_dst = ut_params->obuf;
8752
8753         /* Process crypto operation */
8754         temp_mbuf = ut_params->op->sym->m_src;
8755         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8756                 /* filling lengths */
8757                 while (temp_mbuf) {
8758                         ut_params->op->sym->cipher.data.length
8759                                 += temp_mbuf->pkt_len;
8760                         ut_params->op->sym->auth.data.length
8761                                 += temp_mbuf->pkt_len;
8762                         temp_mbuf = temp_mbuf->next;
8763                 }
8764                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8765                         ut_params->op, 1, 1, 0, 0);
8766         } else {
8767                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8768                                                         ut_params->op);
8769         }
8770         if (ut_params->op == NULL) {
8771                 printf("TestCase %s()-%d line %d failed %s: ",
8772                         __func__, i, __LINE__,
8773                         "failed to process sym crypto op");
8774                 ret = TEST_FAILED;
8775                 goto on_err;
8776         }
8777
8778         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8779                 printf("TestCase %s()-%d line %d failed %s: ",
8780                         __func__, i, __LINE__, "crypto op processing failed");
8781                 ret = TEST_FAILED;
8782                 goto on_err;
8783         }
8784
8785         /* Validate obuf */
8786         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8787                         uint8_t *);
8788         if (oop) {
8789                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8790                                 uint8_t *);
8791         }
8792         if (fragsz_oop)
8793                 fragsz = frag_size_oop;
8794         if (memcmp(ciphertext, output_vec, fragsz)) {
8795                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8796                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8797                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8798                 ret = TEST_FAILED;
8799                 goto on_err;
8800         }
8801
8802         buf = ut_params->op->sym->m_src->next;
8803         if (oop)
8804                 buf = ut_params->op->sym->m_dst->next;
8805
8806         unsigned int off = fragsz;
8807
8808         ecx = 0;
8809         while (buf) {
8810                 ciphertext = rte_pktmbuf_mtod(buf,
8811                                 uint8_t *);
8812                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8813                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8814                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8815                         rte_hexdump(stdout, "reference", output_vec + off,
8816                                         to_trn_tbl[ecx]);
8817                         ret = TEST_FAILED;
8818                         goto on_err;
8819                 }
8820                 off += to_trn_tbl[ecx++];
8821                 buf = buf->next;
8822         }
8823 on_err:
8824         rte_crypto_op_free(ut_params->op);
8825         ut_params->op = NULL;
8826
8827         if (ut_params->sec_session)
8828                 rte_security_session_destroy(ctx, ut_params->sec_session);
8829         ut_params->sec_session = NULL;
8830
8831         rte_pktmbuf_free(ut_params->ibuf);
8832         ut_params->ibuf = NULL;
8833         if (oop) {
8834                 rte_pktmbuf_free(ut_params->obuf);
8835                 ut_params->obuf = NULL;
8836         }
8837
8838         return ret;
8839 }
8840
8841 int
8842 test_pdcp_proto_cplane_encap(int i)
8843 {
8844         return test_pdcp_proto(
8845                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8846                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8847                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8848                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8849                 pdcp_test_params[i].cipher_key_len,
8850                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8851                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8852                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8853                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8854                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8855 }
8856
8857 int
8858 test_pdcp_proto_uplane_encap(int i)
8859 {
8860         return test_pdcp_proto(
8861                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8862                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8863                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8864                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8865                 pdcp_test_params[i].cipher_key_len,
8866                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8867                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8868                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8869                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8870                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8871 }
8872
8873 int
8874 test_pdcp_proto_uplane_encap_with_int(int i)
8875 {
8876         return test_pdcp_proto(
8877                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8878                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8879                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8880                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8881                 pdcp_test_params[i].cipher_key_len,
8882                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8883                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8884                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8885                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8886                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8887 }
8888
8889 int
8890 test_pdcp_proto_cplane_decap(int i)
8891 {
8892         return test_pdcp_proto(
8893                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8894                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8895                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8896                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8897                 pdcp_test_params[i].cipher_key_len,
8898                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8899                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8900                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8901                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8902                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8903 }
8904
8905 int
8906 test_pdcp_proto_uplane_decap(int i)
8907 {
8908         return test_pdcp_proto(
8909                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8910                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8911                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8912                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8913                 pdcp_test_params[i].cipher_key_len,
8914                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8915                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8916                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8917                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8918                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8919 }
8920
8921 int
8922 test_pdcp_proto_uplane_decap_with_int(int i)
8923 {
8924         return test_pdcp_proto(
8925                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8926                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8927                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8928                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8929                 pdcp_test_params[i].cipher_key_len,
8930                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8931                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8932                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8933                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8934                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8935 }
8936
8937 static int
8938 test_PDCP_PROTO_SGL_in_place_32B(void)
8939 {
8940         /* i can be used for running any PDCP case
8941          * In this case it is uplane 12-bit AES-SNOW DL encap
8942          */
8943         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8944         return test_pdcp_proto_SGL(i, IN_PLACE,
8945                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8946                         RTE_CRYPTO_AUTH_OP_GENERATE,
8947                         pdcp_test_data_in[i],
8948                         pdcp_test_data_in_len[i],
8949                         pdcp_test_data_out[i],
8950                         pdcp_test_data_in_len[i]+4,
8951                         32, 0);
8952 }
8953 static int
8954 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8955 {
8956         /* i can be used for running any PDCP case
8957          * In this case it is uplane 18-bit NULL-NULL DL encap
8958          */
8959         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8960         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8961                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8962                         RTE_CRYPTO_AUTH_OP_GENERATE,
8963                         pdcp_test_data_in[i],
8964                         pdcp_test_data_in_len[i],
8965                         pdcp_test_data_out[i],
8966                         pdcp_test_data_in_len[i]+4,
8967                         32, 128);
8968 }
8969 static int
8970 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8971 {
8972         /* i can be used for running any PDCP case
8973          * In this case it is uplane 18-bit AES DL encap
8974          */
8975         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8976                         + DOWNLINK;
8977         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8978                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8979                         RTE_CRYPTO_AUTH_OP_GENERATE,
8980                         pdcp_test_data_in[i],
8981                         pdcp_test_data_in_len[i],
8982                         pdcp_test_data_out[i],
8983                         pdcp_test_data_in_len[i],
8984                         32, 40);
8985 }
8986 static int
8987 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8988 {
8989         /* i can be used for running any PDCP case
8990          * In this case it is cplane 12-bit AES-ZUC DL encap
8991          */
8992         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8993         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8994                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8995                         RTE_CRYPTO_AUTH_OP_GENERATE,
8996                         pdcp_test_data_in[i],
8997                         pdcp_test_data_in_len[i],
8998                         pdcp_test_data_out[i],
8999                         pdcp_test_data_in_len[i]+4,
9000                         128, 32);
9001 }
9002
9003 static int
9004 test_PDCP_SDAP_PROTO_encap_all(void)
9005 {
9006         int i = 0, size = 0;
9007         int err, all_err = TEST_SUCCESS;
9008         const struct pdcp_sdap_test *cur_test;
9009
9010         size = RTE_DIM(list_pdcp_sdap_tests);
9011
9012         for (i = 0; i < size; i++) {
9013                 cur_test = &list_pdcp_sdap_tests[i];
9014                 err = test_pdcp_proto(
9015                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9016                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9017                         cur_test->in_len, cur_test->data_out,
9018                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9019                         cur_test->param.cipher_alg, cur_test->cipher_key,
9020                         cur_test->param.cipher_key_len,
9021                         cur_test->param.auth_alg,
9022                         cur_test->auth_key, cur_test->param.auth_key_len,
9023                         cur_test->bearer, cur_test->param.domain,
9024                         cur_test->packet_direction, cur_test->sn_size,
9025                         cur_test->hfn,
9026                         cur_test->hfn_threshold, SDAP_ENABLED);
9027                 if (err) {
9028                         printf("\t%d) %s: Encapsulation failed\n",
9029                                         cur_test->test_idx,
9030                                         cur_test->param.name);
9031                         err = TEST_FAILED;
9032                 } else {
9033                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9034                                         cur_test->param.name);
9035                         err = TEST_SUCCESS;
9036                 }
9037                 all_err += err;
9038         }
9039
9040         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9041
9042         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9043 }
9044
9045 static int
9046 test_PDCP_PROTO_short_mac(void)
9047 {
9048         int i = 0, size = 0;
9049         int err, all_err = TEST_SUCCESS;
9050         const struct pdcp_short_mac_test *cur_test;
9051
9052         size = RTE_DIM(list_pdcp_smac_tests);
9053
9054         for (i = 0; i < size; i++) {
9055                 cur_test = &list_pdcp_smac_tests[i];
9056                 err = test_pdcp_proto(
9057                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9058                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9059                         cur_test->in_len, cur_test->data_out,
9060                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9061                         RTE_CRYPTO_CIPHER_NULL, NULL,
9062                         0, cur_test->param.auth_alg,
9063                         cur_test->auth_key, cur_test->param.auth_key_len,
9064                         0, cur_test->param.domain, 0, 0,
9065                         0, 0, 0);
9066                 if (err) {
9067                         printf("\t%d) %s: Short MAC test failed\n",
9068                                         cur_test->test_idx,
9069                                         cur_test->param.name);
9070                         err = TEST_FAILED;
9071                 } else {
9072                         printf("\t%d) %s: Short MAC test PASS\n",
9073                                         cur_test->test_idx,
9074                                         cur_test->param.name);
9075                         rte_hexdump(stdout, "MAC I",
9076                                     cur_test->data_out + cur_test->in_len + 2,
9077                                     2);
9078                         err = TEST_SUCCESS;
9079                 }
9080                 all_err += err;
9081         }
9082
9083         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9084
9085         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9086
9087 }
9088
9089 static int
9090 test_PDCP_SDAP_PROTO_decap_all(void)
9091 {
9092         int i = 0, size = 0;
9093         int err, all_err = TEST_SUCCESS;
9094         const struct pdcp_sdap_test *cur_test;
9095
9096         size = RTE_DIM(list_pdcp_sdap_tests);
9097
9098         for (i = 0; i < size; i++) {
9099                 cur_test = &list_pdcp_sdap_tests[i];
9100                 err = test_pdcp_proto(
9101                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9102                         RTE_CRYPTO_AUTH_OP_VERIFY,
9103                         cur_test->data_out,
9104                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9105                         cur_test->data_in, cur_test->in_len,
9106                         cur_test->param.cipher_alg,
9107                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9108                         cur_test->param.auth_alg, cur_test->auth_key,
9109                         cur_test->param.auth_key_len, cur_test->bearer,
9110                         cur_test->param.domain, cur_test->packet_direction,
9111                         cur_test->sn_size, cur_test->hfn,
9112                         cur_test->hfn_threshold, SDAP_ENABLED);
9113                 if (err) {
9114                         printf("\t%d) %s: Decapsulation failed\n",
9115                                         cur_test->test_idx,
9116                                         cur_test->param.name);
9117                         err = TEST_FAILED;
9118                 } else {
9119                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9120                                         cur_test->param.name);
9121                         err = TEST_SUCCESS;
9122                 }
9123                 all_err += err;
9124         }
9125
9126         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9127
9128         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9129 }
9130
9131 static int
9132 test_ipsec_proto_process(const struct ipsec_test_data td[],
9133                          struct ipsec_test_data res_d[],
9134                          int nb_td,
9135                          bool silent,
9136                          const struct ipsec_test_flags *flags)
9137 {
9138         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9139                                 0x0000, 0x001a};
9140         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9141                                 0xe82c, 0x4887};
9142         const struct rte_ipv4_hdr *ipv4 =
9143                         (const struct rte_ipv4_hdr *)td[0].output_text.data;
9144         struct crypto_testsuite_params *ts_params = &testsuite_params;
9145         struct crypto_unittest_params *ut_params = &unittest_params;
9146         struct rte_security_capability_idx sec_cap_idx;
9147         const struct rte_security_capability *sec_cap;
9148         struct rte_security_ipsec_xform ipsec_xform;
9149         uint8_t dev_id = ts_params->valid_devs[0];
9150         enum rte_security_ipsec_sa_direction dir;
9151         struct ipsec_test_data *res_d_tmp = NULL;
9152         int salt_len, i, ret = TEST_SUCCESS;
9153         struct rte_security_ctx *ctx;
9154         uint8_t *input_text;
9155         uint32_t src, dst;
9156         uint32_t verify;
9157
9158         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9159         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9160
9161         /* Use first test data to create session */
9162
9163         /* Copy IPsec xform */
9164         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9165
9166         dir = ipsec_xform.direction;
9167         verify = flags->tunnel_hdr_verify;
9168
9169         memcpy(&src, &ipv4->src_addr, sizeof(ipv4->src_addr));
9170         memcpy(&dst, &ipv4->dst_addr, sizeof(ipv4->dst_addr));
9171
9172         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9173                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9174                         src += 1;
9175                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9176                         dst += 1;
9177         }
9178
9179         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9180                 if (td->ipsec_xform.tunnel.type ==
9181                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9182                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9183                                sizeof(src));
9184                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9185                                sizeof(dst));
9186
9187                         if (flags->df == TEST_IPSEC_SET_DF_0_INNER_1)
9188                                 ipsec_xform.tunnel.ipv4.df = 0;
9189
9190                         if (flags->df == TEST_IPSEC_SET_DF_1_INNER_0)
9191                                 ipsec_xform.tunnel.ipv4.df = 1;
9192
9193                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9194                                 ipsec_xform.tunnel.ipv4.dscp = 0;
9195
9196                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9197                                 ipsec_xform.tunnel.ipv4.dscp =
9198                                                 TEST_IPSEC_DSCP_VAL;
9199
9200                 } else {
9201                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9202                                 ipsec_xform.tunnel.ipv6.dscp = 0;
9203
9204                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9205                                 ipsec_xform.tunnel.ipv6.dscp =
9206                                                 TEST_IPSEC_DSCP_VAL;
9207
9208                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9209                                sizeof(v6_src));
9210                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9211                                sizeof(v6_dst));
9212                 }
9213         }
9214
9215         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9216
9217         sec_cap_idx.action = ut_params->type;
9218         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9219         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9220         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9221         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9222
9223         if (flags->udp_encap)
9224                 ipsec_xform.options.udp_encap = 1;
9225
9226         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9227         if (sec_cap == NULL)
9228                 return TEST_SKIPPED;
9229
9230         /* Copy cipher session parameters */
9231         if (td[0].aead) {
9232                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9233                        sizeof(ut_params->aead_xform));
9234                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9235                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9236
9237                 /* Verify crypto capabilities */
9238                 if (test_ipsec_crypto_caps_aead_verify(
9239                                 sec_cap,
9240                                 &ut_params->aead_xform) != 0) {
9241                         if (!silent)
9242                                 RTE_LOG(INFO, USER1,
9243                                         "Crypto capabilities not supported\n");
9244                         return TEST_SKIPPED;
9245                 }
9246         } else if (td[0].auth_only) {
9247                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9248                        sizeof(ut_params->auth_xform));
9249                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9250
9251                 if (test_ipsec_crypto_caps_auth_verify(
9252                                 sec_cap,
9253                                 &ut_params->auth_xform) != 0) {
9254                         if (!silent)
9255                                 RTE_LOG(INFO, USER1,
9256                                         "Auth crypto capabilities not supported\n");
9257                         return TEST_SKIPPED;
9258                 }
9259         } else {
9260                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9261                        sizeof(ut_params->cipher_xform));
9262                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9263                        sizeof(ut_params->auth_xform));
9264                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9265                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9266                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9267
9268                 /* Verify crypto capabilities */
9269
9270                 if (test_ipsec_crypto_caps_cipher_verify(
9271                                 sec_cap,
9272                                 &ut_params->cipher_xform) != 0) {
9273                         if (!silent)
9274                                 RTE_LOG(INFO, USER1,
9275                                         "Cipher crypto capabilities not supported\n");
9276                         return TEST_SKIPPED;
9277                 }
9278
9279                 if (test_ipsec_crypto_caps_auth_verify(
9280                                 sec_cap,
9281                                 &ut_params->auth_xform) != 0) {
9282                         if (!silent)
9283                                 RTE_LOG(INFO, USER1,
9284                                         "Auth crypto capabilities not supported\n");
9285                         return TEST_SKIPPED;
9286                 }
9287         }
9288
9289         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9290                 return TEST_SKIPPED;
9291
9292         struct rte_security_session_conf sess_conf = {
9293                 .action_type = ut_params->type,
9294                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9295         };
9296
9297         if (td[0].aead || td[0].aes_gmac) {
9298                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9299                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9300         }
9301
9302         if (td[0].aead) {
9303                 sess_conf.ipsec = ipsec_xform;
9304                 sess_conf.crypto_xform = &ut_params->aead_xform;
9305         } else if (td[0].auth_only) {
9306                 sess_conf.ipsec = ipsec_xform;
9307                 sess_conf.crypto_xform = &ut_params->auth_xform;
9308         } else {
9309                 sess_conf.ipsec = ipsec_xform;
9310                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9311                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9312                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9313                 } else {
9314                         sess_conf.crypto_xform = &ut_params->auth_xform;
9315                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9316                 }
9317         }
9318
9319         /* Create security session */
9320         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9321                                         ts_params->session_mpool,
9322                                         ts_params->session_priv_mpool);
9323
9324         if (ut_params->sec_session == NULL)
9325                 return TEST_SKIPPED;
9326
9327         for (i = 0; i < nb_td; i++) {
9328                 if (flags->antireplay &&
9329                     (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)) {
9330                         sess_conf.ipsec.esn.value = td[i].ipsec_xform.esn.value;
9331                         ret = rte_security_session_update(ctx,
9332                                 ut_params->sec_session, &sess_conf);
9333                         if (ret) {
9334                                 printf("Could not update sequence number in "
9335                                        "session\n");
9336                                 return TEST_SKIPPED;
9337                         }
9338                 }
9339
9340                 /* Setup source mbuf payload */
9341                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9342                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9343                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9344
9345                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9346                                 td[i].input_text.len);
9347
9348                 memcpy(input_text, td[i].input_text.data,
9349                        td[i].input_text.len);
9350
9351                 if (test_ipsec_pkt_update(input_text, flags))
9352                         return TEST_FAILED;
9353
9354                 /* Generate crypto op data structure */
9355                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9356                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9357                 if (!ut_params->op) {
9358                         printf("TestCase %s line %d: %s\n",
9359                                 __func__, __LINE__,
9360                                 "failed to allocate crypto op");
9361                         ret = TEST_FAILED;
9362                         goto crypto_op_free;
9363                 }
9364
9365                 /* Attach session to operation */
9366                 rte_security_attach_session(ut_params->op,
9367                                             ut_params->sec_session);
9368
9369                 /* Set crypto operation mbufs */
9370                 ut_params->op->sym->m_src = ut_params->ibuf;
9371                 ut_params->op->sym->m_dst = NULL;
9372
9373                 /* Copy IV in crypto operation when IV generation is disabled */
9374                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9375                     ipsec_xform.options.iv_gen_disable == 1) {
9376                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9377                                                                 uint8_t *,
9378                                                                 IV_OFFSET);
9379                         int len;
9380
9381                         if (td[i].aead)
9382                                 len = td[i].xform.aead.aead.iv.length;
9383                         else if (td[i].aes_gmac)
9384                                 len = td[i].xform.chain.auth.auth.iv.length;
9385                         else
9386                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9387
9388                         memcpy(iv, td[i].iv.data, len);
9389                 }
9390
9391                 /* Process crypto operation */
9392                 process_crypto_request(dev_id, ut_params->op);
9393
9394                 ret = test_ipsec_status_check(&td[i], ut_params->op, flags, dir,
9395                                               i + 1);
9396                 if (ret != TEST_SUCCESS)
9397                         goto crypto_op_free;
9398
9399                 if (res_d != NULL)
9400                         res_d_tmp = &res_d[i];
9401
9402                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9403                                               res_d_tmp, silent, flags);
9404                 if (ret != TEST_SUCCESS)
9405                         goto crypto_op_free;
9406
9407                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9408                                               flags, dir);
9409                 if (ret != TEST_SUCCESS)
9410                         goto crypto_op_free;
9411
9412                 rte_crypto_op_free(ut_params->op);
9413                 ut_params->op = NULL;
9414
9415                 rte_pktmbuf_free(ut_params->ibuf);
9416                 ut_params->ibuf = NULL;
9417         }
9418
9419 crypto_op_free:
9420         rte_crypto_op_free(ut_params->op);
9421         ut_params->op = NULL;
9422
9423         rte_pktmbuf_free(ut_params->ibuf);
9424         ut_params->ibuf = NULL;
9425
9426         if (ut_params->sec_session)
9427                 rte_security_session_destroy(ctx, ut_params->sec_session);
9428         ut_params->sec_session = NULL;
9429
9430         return ret;
9431 }
9432
9433 static int
9434 test_ipsec_proto_known_vec(const void *test_data)
9435 {
9436         struct ipsec_test_data td_outb;
9437         struct ipsec_test_flags flags;
9438
9439         memset(&flags, 0, sizeof(flags));
9440
9441         memcpy(&td_outb, test_data, sizeof(td_outb));
9442
9443         if (td_outb.aes_gmac || td_outb.aead ||
9444             ((td_outb.ipsec_xform.proto != RTE_SECURITY_IPSEC_SA_PROTO_AH) &&
9445              (td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL))) {
9446                 /* Disable IV gen to be able to test with known vectors */
9447                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9448         }
9449
9450         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9451 }
9452
9453 static int
9454 test_ipsec_proto_known_vec_inb(const void *test_data)
9455 {
9456         const struct ipsec_test_data *td = test_data;
9457         struct ipsec_test_flags flags;
9458         struct ipsec_test_data td_inb;
9459
9460         memset(&flags, 0, sizeof(flags));
9461
9462         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9463                 test_ipsec_td_in_from_out(td, &td_inb);
9464         else
9465                 memcpy(&td_inb, td, sizeof(td_inb));
9466
9467         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9468 }
9469
9470 static int
9471 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9472 {
9473         struct ipsec_test_data td_outb;
9474         struct ipsec_test_flags flags;
9475
9476         memset(&flags, 0, sizeof(flags));
9477         flags.fragment = true;
9478
9479         memcpy(&td_outb, test_data, sizeof(td_outb));
9480
9481         /* Disable IV gen to be able to test with known vectors */
9482         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9483
9484         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9485 }
9486
9487 static int
9488 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9489 {
9490         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9491         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9492         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9493         int ret;
9494
9495         if (flags->iv_gen ||
9496             flags->sa_expiry_pkts_soft ||
9497             flags->sa_expiry_pkts_hard)
9498                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9499
9500         for (i = 0; i < RTE_DIM(alg_list); i++) {
9501                 test_ipsec_td_prepare(alg_list[i].param1,
9502                                       alg_list[i].param2,
9503                                       flags,
9504                                       td_outb,
9505                                       nb_pkts);
9506
9507                 if (!td_outb->aead) {
9508                         enum rte_crypto_cipher_algorithm cipher_alg;
9509                         enum rte_crypto_auth_algorithm auth_alg;
9510
9511                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9512                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9513
9514                         if (td_outb->aes_gmac && cipher_alg != RTE_CRYPTO_CIPHER_NULL)
9515                                 continue;
9516
9517                         /* ICV is not applicable for NULL auth */
9518                         if (flags->icv_corrupt &&
9519                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9520                                 continue;
9521
9522                         /* IV is not applicable for NULL cipher */
9523                         if (flags->iv_gen &&
9524                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9525                                 continue;
9526                 }
9527
9528                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9529                                                flags);
9530                 if (ret == TEST_SKIPPED)
9531                         continue;
9532
9533                 if (ret == TEST_FAILED)
9534                         return TEST_FAILED;
9535
9536                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9537
9538                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9539                                                flags);
9540                 if (ret == TEST_SKIPPED)
9541                         continue;
9542
9543                 if (ret == TEST_FAILED)
9544                         return TEST_FAILED;
9545
9546                 if (flags->display_alg)
9547                         test_ipsec_display_alg(alg_list[i].param1,
9548                                                alg_list[i].param2);
9549
9550                 pass_cnt++;
9551         }
9552
9553         if (pass_cnt > 0)
9554                 return TEST_SUCCESS;
9555         else
9556                 return TEST_SKIPPED;
9557 }
9558
9559 static int
9560 test_ipsec_ah_proto_all(const struct ipsec_test_flags *flags)
9561 {
9562         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9563         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9564         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9565         int ret;
9566
9567         for (i = 0; i < RTE_DIM(ah_alg_list); i++) {
9568                 test_ipsec_td_prepare(ah_alg_list[i].param1,
9569                                       ah_alg_list[i].param2,
9570                                       flags,
9571                                       td_outb,
9572                                       nb_pkts);
9573
9574                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9575                                                flags);
9576                 if (ret == TEST_SKIPPED)
9577                         continue;
9578
9579                 if (ret == TEST_FAILED)
9580                         return TEST_FAILED;
9581
9582                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9583
9584                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9585                                                flags);
9586                 if (ret == TEST_SKIPPED)
9587                         continue;
9588
9589                 if (ret == TEST_FAILED)
9590                         return TEST_FAILED;
9591
9592                 if (flags->display_alg)
9593                         test_ipsec_display_alg(ah_alg_list[i].param1,
9594                                                ah_alg_list[i].param2);
9595
9596                 pass_cnt++;
9597         }
9598
9599         if (pass_cnt > 0)
9600                 return TEST_SUCCESS;
9601         else
9602                 return TEST_SKIPPED;
9603 }
9604
9605 static int
9606 test_ipsec_proto_display_list(const void *data __rte_unused)
9607 {
9608         struct ipsec_test_flags flags;
9609
9610         memset(&flags, 0, sizeof(flags));
9611
9612         flags.display_alg = true;
9613
9614         return test_ipsec_proto_all(&flags);
9615 }
9616
9617 static int
9618 test_ipsec_proto_ah_tunnel_ipv4(const void *data __rte_unused)
9619 {
9620         struct ipsec_test_flags flags;
9621
9622         memset(&flags, 0, sizeof(flags));
9623
9624         flags.ah = true;
9625         flags.display_alg = true;
9626
9627         return test_ipsec_ah_proto_all(&flags);
9628 }
9629
9630 static int
9631 test_ipsec_proto_ah_transport_ipv4(const void *data __rte_unused)
9632 {
9633         struct ipsec_test_flags flags;
9634
9635         memset(&flags, 0, sizeof(flags));
9636
9637         flags.ah = true;
9638         flags.transport = true;
9639
9640         return test_ipsec_ah_proto_all(&flags);
9641 }
9642
9643 static int
9644 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9645 {
9646         struct ipsec_test_flags flags;
9647
9648         memset(&flags, 0, sizeof(flags));
9649
9650         flags.iv_gen = true;
9651
9652         return test_ipsec_proto_all(&flags);
9653 }
9654
9655 static int
9656 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9657 {
9658         struct ipsec_test_flags flags;
9659
9660         memset(&flags, 0, sizeof(flags));
9661
9662         flags.sa_expiry_pkts_soft = true;
9663
9664         return test_ipsec_proto_all(&flags);
9665 }
9666
9667 static int
9668 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9669 {
9670         struct ipsec_test_flags flags;
9671
9672         memset(&flags, 0, sizeof(flags));
9673
9674         flags.sa_expiry_pkts_hard = true;
9675
9676         return test_ipsec_proto_all(&flags);
9677 }
9678
9679 static int
9680 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9681 {
9682         struct ipsec_test_flags flags;
9683
9684         memset(&flags, 0, sizeof(flags));
9685
9686         flags.icv_corrupt = true;
9687
9688         return test_ipsec_proto_all(&flags);
9689 }
9690
9691 static int
9692 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9693 {
9694         struct ipsec_test_flags flags;
9695
9696         memset(&flags, 0, sizeof(flags));
9697
9698         flags.udp_encap = true;
9699
9700         return test_ipsec_proto_all(&flags);
9701 }
9702
9703 static int
9704 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9705 {
9706         struct ipsec_test_flags flags;
9707
9708         memset(&flags, 0, sizeof(flags));
9709
9710         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9711
9712         return test_ipsec_proto_all(&flags);
9713 }
9714
9715 static int
9716 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9717 {
9718         struct ipsec_test_flags flags;
9719
9720         memset(&flags, 0, sizeof(flags));
9721
9722         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9723
9724         return test_ipsec_proto_all(&flags);
9725 }
9726
9727 static int
9728 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9729 {
9730         struct ipsec_test_flags flags;
9731
9732         memset(&flags, 0, sizeof(flags));
9733
9734         flags.udp_encap = true;
9735         flags.udp_ports_verify = true;
9736
9737         return test_ipsec_proto_all(&flags);
9738 }
9739
9740 static int
9741 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9742 {
9743         struct ipsec_test_flags flags;
9744
9745         memset(&flags, 0, sizeof(flags));
9746
9747         flags.ip_csum = true;
9748
9749         return test_ipsec_proto_all(&flags);
9750 }
9751
9752 static int
9753 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9754 {
9755         struct ipsec_test_flags flags;
9756
9757         memset(&flags, 0, sizeof(flags));
9758
9759         flags.l4_csum = true;
9760
9761         return test_ipsec_proto_all(&flags);
9762 }
9763
9764 static int
9765 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9766 {
9767         struct ipsec_test_flags flags;
9768
9769         memset(&flags, 0, sizeof(flags));
9770
9771         flags.ipv6 = false;
9772         flags.tunnel_ipv6 = false;
9773
9774         return test_ipsec_proto_all(&flags);
9775 }
9776
9777 static int
9778 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9779 {
9780         struct ipsec_test_flags flags;
9781
9782         memset(&flags, 0, sizeof(flags));
9783
9784         flags.ipv6 = true;
9785         flags.tunnel_ipv6 = true;
9786
9787         return test_ipsec_proto_all(&flags);
9788 }
9789
9790 static int
9791 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9792 {
9793         struct ipsec_test_flags flags;
9794
9795         memset(&flags, 0, sizeof(flags));
9796
9797         flags.ipv6 = false;
9798         flags.tunnel_ipv6 = true;
9799
9800         return test_ipsec_proto_all(&flags);
9801 }
9802
9803 static int
9804 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9805 {
9806         struct ipsec_test_flags flags;
9807
9808         memset(&flags, 0, sizeof(flags));
9809
9810         flags.ipv6 = true;
9811         flags.tunnel_ipv6 = false;
9812
9813         return test_ipsec_proto_all(&flags);
9814 }
9815
9816 static int
9817 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9818 {
9819         struct ipsec_test_flags flags;
9820
9821         memset(&flags, 0, sizeof(flags));
9822
9823         flags.ipv6 = false;
9824         flags.transport = true;
9825
9826         return test_ipsec_proto_all(&flags);
9827 }
9828
9829 static int
9830 test_ipsec_proto_transport_l4_csum(const void *data __rte_unused)
9831 {
9832         struct ipsec_test_flags flags = {
9833                 .l4_csum = true,
9834                 .transport = true,
9835         };
9836
9837         return test_ipsec_proto_all(&flags);
9838 }
9839
9840 static int
9841 test_ipsec_proto_stats(const void *data __rte_unused)
9842 {
9843         struct ipsec_test_flags flags;
9844
9845         memset(&flags, 0, sizeof(flags));
9846
9847         flags.stats_success = true;
9848
9849         return test_ipsec_proto_all(&flags);
9850 }
9851
9852 static int
9853 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9854 {
9855         struct ipsec_test_flags flags;
9856
9857         memset(&flags, 0, sizeof(flags));
9858
9859         flags.fragment = true;
9860
9861         return test_ipsec_proto_all(&flags);
9862
9863 }
9864
9865 static int
9866 test_ipsec_proto_copy_df_inner_0(const void *data __rte_unused)
9867 {
9868         struct ipsec_test_flags flags;
9869
9870         memset(&flags, 0, sizeof(flags));
9871
9872         flags.df = TEST_IPSEC_COPY_DF_INNER_0;
9873
9874         return test_ipsec_proto_all(&flags);
9875 }
9876
9877 static int
9878 test_ipsec_proto_copy_df_inner_1(const void *data __rte_unused)
9879 {
9880         struct ipsec_test_flags flags;
9881
9882         memset(&flags, 0, sizeof(flags));
9883
9884         flags.df = TEST_IPSEC_COPY_DF_INNER_1;
9885
9886         return test_ipsec_proto_all(&flags);
9887 }
9888
9889 static int
9890 test_ipsec_proto_set_df_0_inner_1(const void *data __rte_unused)
9891 {
9892         struct ipsec_test_flags flags;
9893
9894         memset(&flags, 0, sizeof(flags));
9895
9896         flags.df = TEST_IPSEC_SET_DF_0_INNER_1;
9897
9898         return test_ipsec_proto_all(&flags);
9899 }
9900
9901 static int
9902 test_ipsec_proto_set_df_1_inner_0(const void *data __rte_unused)
9903 {
9904         struct ipsec_test_flags flags;
9905
9906         memset(&flags, 0, sizeof(flags));
9907
9908         flags.df = TEST_IPSEC_SET_DF_1_INNER_0;
9909
9910         return test_ipsec_proto_all(&flags);
9911 }
9912
9913 static int
9914 test_ipsec_proto_ipv4_copy_dscp_inner_0(const void *data __rte_unused)
9915 {
9916         struct ipsec_test_flags flags;
9917
9918         memset(&flags, 0, sizeof(flags));
9919
9920         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9921
9922         return test_ipsec_proto_all(&flags);
9923 }
9924
9925 static int
9926 test_ipsec_proto_ipv4_copy_dscp_inner_1(const void *data __rte_unused)
9927 {
9928         struct ipsec_test_flags flags;
9929
9930         memset(&flags, 0, sizeof(flags));
9931
9932         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9933
9934         return test_ipsec_proto_all(&flags);
9935 }
9936
9937 static int
9938 test_ipsec_proto_ipv4_set_dscp_0_inner_1(const void *data __rte_unused)
9939 {
9940         struct ipsec_test_flags flags;
9941
9942         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9943                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9944                 return TEST_SKIPPED;
9945
9946         memset(&flags, 0, sizeof(flags));
9947
9948         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9949
9950         return test_ipsec_proto_all(&flags);
9951 }
9952
9953 static int
9954 test_ipsec_proto_ipv4_set_dscp_1_inner_0(const void *data __rte_unused)
9955 {
9956         struct ipsec_test_flags flags;
9957
9958         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9959                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9960                 return TEST_SKIPPED;
9961
9962         memset(&flags, 0, sizeof(flags));
9963
9964         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
9965
9966         return test_ipsec_proto_all(&flags);
9967 }
9968
9969 static int
9970 test_ipsec_proto_ipv6_copy_dscp_inner_0(const void *data __rte_unused)
9971 {
9972         struct ipsec_test_flags flags;
9973
9974         memset(&flags, 0, sizeof(flags));
9975
9976         flags.ipv6 = true;
9977         flags.tunnel_ipv6 = true;
9978         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9979
9980         return test_ipsec_proto_all(&flags);
9981 }
9982
9983 static int
9984 test_ipsec_proto_ipv6_copy_dscp_inner_1(const void *data __rte_unused)
9985 {
9986         struct ipsec_test_flags flags;
9987
9988         memset(&flags, 0, sizeof(flags));
9989
9990         flags.ipv6 = true;
9991         flags.tunnel_ipv6 = true;
9992         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9993
9994         return test_ipsec_proto_all(&flags);
9995 }
9996
9997 static int
9998 test_ipsec_proto_ipv6_set_dscp_0_inner_1(const void *data __rte_unused)
9999 {
10000         struct ipsec_test_flags flags;
10001
10002         if (gbl_driver_id == rte_cryptodev_driver_id_get(
10003                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
10004                 return TEST_SKIPPED;
10005
10006         memset(&flags, 0, sizeof(flags));
10007
10008         flags.ipv6 = true;
10009         flags.tunnel_ipv6 = true;
10010         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
10011
10012         return test_ipsec_proto_all(&flags);
10013 }
10014
10015 static int
10016 test_ipsec_proto_ipv6_set_dscp_1_inner_0(const void *data __rte_unused)
10017 {
10018         struct ipsec_test_flags flags;
10019
10020         if (gbl_driver_id == rte_cryptodev_driver_id_get(
10021                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
10022                 return TEST_SKIPPED;
10023
10024         memset(&flags, 0, sizeof(flags));
10025
10026         flags.ipv6 = true;
10027         flags.tunnel_ipv6 = true;
10028         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
10029
10030         return test_ipsec_proto_all(&flags);
10031 }
10032
10033 static int
10034 test_ipsec_pkt_replay(const void *test_data, const uint64_t esn[],
10035                       bool replayed_pkt[], uint32_t nb_pkts, bool esn_en,
10036                       uint64_t winsz)
10037 {
10038         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
10039         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
10040         struct ipsec_test_flags flags;
10041         uint32_t i = 0, ret = 0;
10042
10043         memset(&flags, 0, sizeof(flags));
10044         flags.antireplay = true;
10045
10046         for (i = 0; i < nb_pkts; i++) {
10047                 memcpy(&td_outb[i], test_data, sizeof(td_outb[i]));
10048                 td_outb[i].ipsec_xform.options.iv_gen_disable = 1;
10049                 td_outb[i].ipsec_xform.replay_win_sz = winsz;
10050                 td_outb[i].ipsec_xform.options.esn = esn_en;
10051         }
10052
10053         for (i = 0; i < nb_pkts; i++)
10054                 td_outb[i].ipsec_xform.esn.value = esn[i];
10055
10056         ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
10057                                        &flags);
10058         if (ret != TEST_SUCCESS)
10059                 return ret;
10060
10061         test_ipsec_td_update(td_inb, td_outb, nb_pkts, &flags);
10062
10063         for (i = 0; i < nb_pkts; i++) {
10064                 td_inb[i].ipsec_xform.options.esn = esn_en;
10065                 /* Set antireplay flag for packets to be dropped */
10066                 td_inb[i].ar_packet = replayed_pkt[i];
10067         }
10068
10069         ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
10070                                        &flags);
10071
10072         return ret;
10073 }
10074
10075 static int
10076 test_ipsec_proto_pkt_antireplay(const void *test_data, uint64_t winsz)
10077 {
10078
10079         uint32_t nb_pkts = 5;
10080         bool replayed_pkt[5];
10081         uint64_t esn[5];
10082
10083         /* 1. Advance the TOP of the window to WS * 2 */
10084         esn[0] = winsz * 2;
10085         /* 2. Test sequence number within the new window(WS + 1) */
10086         esn[1] = winsz + 1;
10087         /* 3. Test sequence number less than the window BOTTOM */
10088         esn[2] = winsz;
10089         /* 4. Test sequence number in the middle of the window */
10090         esn[3] = winsz + (winsz / 2);
10091         /* 5. Test replay of the packet in the middle of the window */
10092         esn[4] = winsz + (winsz / 2);
10093
10094         replayed_pkt[0] = false;
10095         replayed_pkt[1] = false;
10096         replayed_pkt[2] = true;
10097         replayed_pkt[3] = false;
10098         replayed_pkt[4] = true;
10099
10100         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10101                                      false, winsz);
10102 }
10103
10104 static int
10105 test_ipsec_proto_pkt_antireplay1024(const void *test_data)
10106 {
10107         return test_ipsec_proto_pkt_antireplay(test_data, 1024);
10108 }
10109
10110 static int
10111 test_ipsec_proto_pkt_antireplay2048(const void *test_data)
10112 {
10113         return test_ipsec_proto_pkt_antireplay(test_data, 2048);
10114 }
10115
10116 static int
10117 test_ipsec_proto_pkt_antireplay4096(const void *test_data)
10118 {
10119         return test_ipsec_proto_pkt_antireplay(test_data, 4096);
10120 }
10121
10122 static int
10123 test_ipsec_proto_pkt_esn_antireplay(const void *test_data, uint64_t winsz)
10124 {
10125
10126         uint32_t nb_pkts = 7;
10127         bool replayed_pkt[7];
10128         uint64_t esn[7];
10129
10130         /* Set the initial sequence number */
10131         esn[0] = (uint64_t)(0xFFFFFFFF - winsz);
10132         /* 1. Advance the TOP of the window to (1<<32 + WS/2) */
10133         esn[1] = (uint64_t)((1ULL << 32) + (winsz / 2));
10134         /* 2. Test sequence number within new window (1<<32 + WS/2 + 1) */
10135         esn[2] = (uint64_t)((1ULL << 32) - (winsz / 2) + 1);
10136         /* 3. Test with sequence number within window (1<<32 - 1) */
10137         esn[3] = (uint64_t)((1ULL << 32) - 1);
10138         /* 4. Test with sequence number within window (1<<32 - 1) */
10139         esn[4] = (uint64_t)(1ULL << 32);
10140         /* 5. Test with duplicate sequence number within
10141          * new window (1<<32 - 1)
10142          */
10143         esn[5] = (uint64_t)((1ULL << 32) - 1);
10144         /* 6. Test with duplicate sequence number within new window (1<<32) */
10145         esn[6] = (uint64_t)(1ULL << 32);
10146
10147         replayed_pkt[0] = false;
10148         replayed_pkt[1] = false;
10149         replayed_pkt[2] = false;
10150         replayed_pkt[3] = false;
10151         replayed_pkt[4] = false;
10152         replayed_pkt[5] = true;
10153         replayed_pkt[6] = true;
10154
10155         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10156                                      true, winsz);
10157 }
10158
10159 static int
10160 test_ipsec_proto_pkt_esn_antireplay1024(const void *test_data)
10161 {
10162         return test_ipsec_proto_pkt_esn_antireplay(test_data, 1024);
10163 }
10164
10165 static int
10166 test_ipsec_proto_pkt_esn_antireplay2048(const void *test_data)
10167 {
10168         return test_ipsec_proto_pkt_esn_antireplay(test_data, 2048);
10169 }
10170
10171 static int
10172 test_ipsec_proto_pkt_esn_antireplay4096(const void *test_data)
10173 {
10174         return test_ipsec_proto_pkt_esn_antireplay(test_data, 4096);
10175 }
10176
10177 static int
10178 test_PDCP_PROTO_all(void)
10179 {
10180         struct crypto_testsuite_params *ts_params = &testsuite_params;
10181         struct crypto_unittest_params *ut_params = &unittest_params;
10182         struct rte_cryptodev_info dev_info;
10183         int status;
10184
10185         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10186         uint64_t feat_flags = dev_info.feature_flags;
10187
10188         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
10189                 return TEST_SKIPPED;
10190
10191         /* Set action type */
10192         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10193                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10194                 gbl_action_type;
10195
10196         if (security_proto_supported(ut_params->type,
10197                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
10198                 return TEST_SKIPPED;
10199
10200         status = test_PDCP_PROTO_cplane_encap_all();
10201         status += test_PDCP_PROTO_cplane_decap_all();
10202         status += test_PDCP_PROTO_uplane_encap_all();
10203         status += test_PDCP_PROTO_uplane_decap_all();
10204         status += test_PDCP_PROTO_SGL_in_place_32B();
10205         status += test_PDCP_PROTO_SGL_oop_32B_128B();
10206         status += test_PDCP_PROTO_SGL_oop_32B_40B();
10207         status += test_PDCP_PROTO_SGL_oop_128B_32B();
10208         status += test_PDCP_SDAP_PROTO_encap_all();
10209         status += test_PDCP_SDAP_PROTO_decap_all();
10210         status += test_PDCP_PROTO_short_mac();
10211
10212         if (status)
10213                 return TEST_FAILED;
10214         else
10215                 return TEST_SUCCESS;
10216 }
10217
10218 static int
10219 test_ipsec_proto_ipv4_ttl_decrement(const void *data __rte_unused)
10220 {
10221         struct ipsec_test_flags flags = {
10222                 .dec_ttl_or_hop_limit = true
10223         };
10224
10225         return test_ipsec_proto_all(&flags);
10226 }
10227
10228 static int
10229 test_ipsec_proto_ipv6_hop_limit_decrement(const void *data __rte_unused)
10230 {
10231         struct ipsec_test_flags flags = {
10232                 .ipv6 = true,
10233                 .dec_ttl_or_hop_limit = true
10234         };
10235
10236         return test_ipsec_proto_all(&flags);
10237 }
10238
10239 static int
10240 test_docsis_proto_uplink(const void *data)
10241 {
10242         const struct docsis_test_data *d_td = data;
10243         struct crypto_testsuite_params *ts_params = &testsuite_params;
10244         struct crypto_unittest_params *ut_params = &unittest_params;
10245         uint8_t *plaintext = NULL;
10246         uint8_t *ciphertext = NULL;
10247         uint8_t *iv_ptr;
10248         int32_t cipher_len, crc_len;
10249         uint32_t crc_data_len;
10250         int ret = TEST_SUCCESS;
10251
10252         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10253                                         rte_cryptodev_get_sec_ctx(
10254                                                 ts_params->valid_devs[0]);
10255
10256         /* Verify the capabilities */
10257         struct rte_security_capability_idx sec_cap_idx;
10258         const struct rte_security_capability *sec_cap;
10259         const struct rte_cryptodev_capabilities *crypto_cap;
10260         const struct rte_cryptodev_symmetric_capability *sym_cap;
10261         int j = 0;
10262
10263         /* Set action type */
10264         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10265                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10266                 gbl_action_type;
10267
10268         if (security_proto_supported(ut_params->type,
10269                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10270                 return TEST_SKIPPED;
10271
10272         sec_cap_idx.action = ut_params->type;
10273         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10274         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
10275
10276         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10277         if (sec_cap == NULL)
10278                 return TEST_SKIPPED;
10279
10280         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10281                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10282                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10283                                 crypto_cap->sym.xform_type ==
10284                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10285                                 crypto_cap->sym.cipher.algo ==
10286                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10287                         sym_cap = &crypto_cap->sym;
10288                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10289                                                 d_td->key.len,
10290                                                 d_td->iv.len) == 0)
10291                                 break;
10292                 }
10293         }
10294
10295         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10296                 return TEST_SKIPPED;
10297
10298         /* Setup source mbuf payload */
10299         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10300         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10301                         rte_pktmbuf_tailroom(ut_params->ibuf));
10302
10303         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10304                         d_td->ciphertext.len);
10305
10306         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
10307
10308         /* Setup cipher session parameters */
10309         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10310         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10311         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
10312         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10313         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10314         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10315         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10316         ut_params->cipher_xform.next = NULL;
10317
10318         /* Setup DOCSIS session parameters */
10319         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
10320
10321         struct rte_security_session_conf sess_conf = {
10322                 .action_type = ut_params->type,
10323                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10324                 .docsis = ut_params->docsis_xform,
10325                 .crypto_xform = &ut_params->cipher_xform,
10326         };
10327
10328         /* Create security session */
10329         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10330                                         ts_params->session_mpool,
10331                                         ts_params->session_priv_mpool);
10332
10333         if (!ut_params->sec_session) {
10334                 printf("Test function %s line %u: failed to allocate session\n",
10335                         __func__, __LINE__);
10336                 ret = TEST_FAILED;
10337                 goto on_err;
10338         }
10339
10340         /* Generate crypto op data structure */
10341         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10342                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10343         if (!ut_params->op) {
10344                 printf("Test function %s line %u: failed to allocate symmetric "
10345                         "crypto operation\n", __func__, __LINE__);
10346                 ret = TEST_FAILED;
10347                 goto on_err;
10348         }
10349
10350         /* Setup CRC operation parameters */
10351         crc_len = d_td->ciphertext.no_crc == false ?
10352                         (d_td->ciphertext.len -
10353                                 d_td->ciphertext.crc_offset -
10354                                 RTE_ETHER_CRC_LEN) :
10355                         0;
10356         crc_len = crc_len > 0 ? crc_len : 0;
10357         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
10358         ut_params->op->sym->auth.data.length = crc_len;
10359         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
10360
10361         /* Setup cipher operation parameters */
10362         cipher_len = d_td->ciphertext.no_cipher == false ?
10363                         (d_td->ciphertext.len -
10364                                 d_td->ciphertext.cipher_offset) :
10365                         0;
10366         cipher_len = cipher_len > 0 ? cipher_len : 0;
10367         ut_params->op->sym->cipher.data.length = cipher_len;
10368         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
10369
10370         /* Setup cipher IV */
10371         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10372         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10373
10374         /* Attach session to operation */
10375         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10376
10377         /* Set crypto operation mbufs */
10378         ut_params->op->sym->m_src = ut_params->ibuf;
10379         ut_params->op->sym->m_dst = NULL;
10380
10381         /* Process crypto operation */
10382         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10383                         NULL) {
10384                 printf("Test function %s line %u: failed to process security "
10385                         "crypto op\n", __func__, __LINE__);
10386                 ret = TEST_FAILED;
10387                 goto on_err;
10388         }
10389
10390         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10391                 printf("Test function %s line %u: failed to process crypto op\n",
10392                         __func__, __LINE__);
10393                 ret = TEST_FAILED;
10394                 goto on_err;
10395         }
10396
10397         /* Validate plaintext */
10398         plaintext = ciphertext;
10399
10400         if (memcmp(plaintext, d_td->plaintext.data,
10401                         d_td->plaintext.len - crc_data_len)) {
10402                 printf("Test function %s line %u: plaintext not as expected\n",
10403                         __func__, __LINE__);
10404                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
10405                                 d_td->plaintext.len);
10406                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
10407                 ret = TEST_FAILED;
10408                 goto on_err;
10409         }
10410
10411 on_err:
10412         rte_crypto_op_free(ut_params->op);
10413         ut_params->op = NULL;
10414
10415         if (ut_params->sec_session)
10416                 rte_security_session_destroy(ctx, ut_params->sec_session);
10417         ut_params->sec_session = NULL;
10418
10419         rte_pktmbuf_free(ut_params->ibuf);
10420         ut_params->ibuf = NULL;
10421
10422         return ret;
10423 }
10424
10425 static int
10426 test_docsis_proto_downlink(const void *data)
10427 {
10428         const struct docsis_test_data *d_td = data;
10429         struct crypto_testsuite_params *ts_params = &testsuite_params;
10430         struct crypto_unittest_params *ut_params = &unittest_params;
10431         uint8_t *plaintext = NULL;
10432         uint8_t *ciphertext = NULL;
10433         uint8_t *iv_ptr;
10434         int32_t cipher_len, crc_len;
10435         int ret = TEST_SUCCESS;
10436
10437         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10438                                         rte_cryptodev_get_sec_ctx(
10439                                                 ts_params->valid_devs[0]);
10440
10441         /* Verify the capabilities */
10442         struct rte_security_capability_idx sec_cap_idx;
10443         const struct rte_security_capability *sec_cap;
10444         const struct rte_cryptodev_capabilities *crypto_cap;
10445         const struct rte_cryptodev_symmetric_capability *sym_cap;
10446         int j = 0;
10447
10448         /* Set action type */
10449         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10450                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10451                 gbl_action_type;
10452
10453         if (security_proto_supported(ut_params->type,
10454                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10455                 return TEST_SKIPPED;
10456
10457         sec_cap_idx.action = ut_params->type;
10458         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10459         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10460
10461         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10462         if (sec_cap == NULL)
10463                 return TEST_SKIPPED;
10464
10465         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10466                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10467                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10468                                 crypto_cap->sym.xform_type ==
10469                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10470                                 crypto_cap->sym.cipher.algo ==
10471                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10472                         sym_cap = &crypto_cap->sym;
10473                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10474                                                 d_td->key.len,
10475                                                 d_td->iv.len) == 0)
10476                                 break;
10477                 }
10478         }
10479
10480         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10481                 return TEST_SKIPPED;
10482
10483         /* Setup source mbuf payload */
10484         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10485         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10486                         rte_pktmbuf_tailroom(ut_params->ibuf));
10487
10488         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10489                         d_td->plaintext.len);
10490
10491         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10492
10493         /* Setup cipher session parameters */
10494         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10495         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10496         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10497         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10498         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10499         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10500         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10501         ut_params->cipher_xform.next = NULL;
10502
10503         /* Setup DOCSIS session parameters */
10504         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10505
10506         struct rte_security_session_conf sess_conf = {
10507                 .action_type = ut_params->type,
10508                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10509                 .docsis = ut_params->docsis_xform,
10510                 .crypto_xform = &ut_params->cipher_xform,
10511         };
10512
10513         /* Create security session */
10514         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10515                                         ts_params->session_mpool,
10516                                         ts_params->session_priv_mpool);
10517
10518         if (!ut_params->sec_session) {
10519                 printf("Test function %s line %u: failed to allocate session\n",
10520                         __func__, __LINE__);
10521                 ret = TEST_FAILED;
10522                 goto on_err;
10523         }
10524
10525         /* Generate crypto op data structure */
10526         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10527                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10528         if (!ut_params->op) {
10529                 printf("Test function %s line %u: failed to allocate symmetric "
10530                         "crypto operation\n", __func__, __LINE__);
10531                 ret = TEST_FAILED;
10532                 goto on_err;
10533         }
10534
10535         /* Setup CRC operation parameters */
10536         crc_len = d_td->plaintext.no_crc == false ?
10537                         (d_td->plaintext.len -
10538                                 d_td->plaintext.crc_offset -
10539                                 RTE_ETHER_CRC_LEN) :
10540                         0;
10541         crc_len = crc_len > 0 ? crc_len : 0;
10542         ut_params->op->sym->auth.data.length = crc_len;
10543         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10544
10545         /* Setup cipher operation parameters */
10546         cipher_len = d_td->plaintext.no_cipher == false ?
10547                         (d_td->plaintext.len -
10548                                 d_td->plaintext.cipher_offset) :
10549                         0;
10550         cipher_len = cipher_len > 0 ? cipher_len : 0;
10551         ut_params->op->sym->cipher.data.length = cipher_len;
10552         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10553
10554         /* Setup cipher IV */
10555         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10556         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10557
10558         /* Attach session to operation */
10559         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10560
10561         /* Set crypto operation mbufs */
10562         ut_params->op->sym->m_src = ut_params->ibuf;
10563         ut_params->op->sym->m_dst = NULL;
10564
10565         /* Process crypto operation */
10566         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10567                         NULL) {
10568                 printf("Test function %s line %u: failed to process crypto op\n",
10569                         __func__, __LINE__);
10570                 ret = TEST_FAILED;
10571                 goto on_err;
10572         }
10573
10574         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10575                 printf("Test function %s line %u: crypto op processing failed\n",
10576                         __func__, __LINE__);
10577                 ret = TEST_FAILED;
10578                 goto on_err;
10579         }
10580
10581         /* Validate ciphertext */
10582         ciphertext = plaintext;
10583
10584         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10585                 printf("Test function %s line %u: plaintext not as expected\n",
10586                         __func__, __LINE__);
10587                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10588                                 d_td->ciphertext.len);
10589                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10590                 ret = TEST_FAILED;
10591                 goto on_err;
10592         }
10593
10594 on_err:
10595         rte_crypto_op_free(ut_params->op);
10596         ut_params->op = NULL;
10597
10598         if (ut_params->sec_session)
10599                 rte_security_session_destroy(ctx, ut_params->sec_session);
10600         ut_params->sec_session = NULL;
10601
10602         rte_pktmbuf_free(ut_params->ibuf);
10603         ut_params->ibuf = NULL;
10604
10605         return ret;
10606 }
10607 #endif
10608
10609 static int
10610 test_AES_GCM_authenticated_encryption_test_case_1(void)
10611 {
10612         return test_authenticated_encryption(&gcm_test_case_1);
10613 }
10614
10615 static int
10616 test_AES_GCM_authenticated_encryption_test_case_2(void)
10617 {
10618         return test_authenticated_encryption(&gcm_test_case_2);
10619 }
10620
10621 static int
10622 test_AES_GCM_authenticated_encryption_test_case_3(void)
10623 {
10624         return test_authenticated_encryption(&gcm_test_case_3);
10625 }
10626
10627 static int
10628 test_AES_GCM_authenticated_encryption_test_case_4(void)
10629 {
10630         return test_authenticated_encryption(&gcm_test_case_4);
10631 }
10632
10633 static int
10634 test_AES_GCM_authenticated_encryption_test_case_5(void)
10635 {
10636         return test_authenticated_encryption(&gcm_test_case_5);
10637 }
10638
10639 static int
10640 test_AES_GCM_authenticated_encryption_test_case_6(void)
10641 {
10642         return test_authenticated_encryption(&gcm_test_case_6);
10643 }
10644
10645 static int
10646 test_AES_GCM_authenticated_encryption_test_case_7(void)
10647 {
10648         return test_authenticated_encryption(&gcm_test_case_7);
10649 }
10650
10651 static int
10652 test_AES_GCM_authenticated_encryption_test_case_8(void)
10653 {
10654         return test_authenticated_encryption(&gcm_test_case_8);
10655 }
10656
10657 static int
10658 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10659 {
10660         return test_authenticated_encryption(&gcm_J0_test_case_1);
10661 }
10662
10663 static int
10664 test_AES_GCM_auth_encryption_test_case_192_1(void)
10665 {
10666         return test_authenticated_encryption(&gcm_test_case_192_1);
10667 }
10668
10669 static int
10670 test_AES_GCM_auth_encryption_test_case_192_2(void)
10671 {
10672         return test_authenticated_encryption(&gcm_test_case_192_2);
10673 }
10674
10675 static int
10676 test_AES_GCM_auth_encryption_test_case_192_3(void)
10677 {
10678         return test_authenticated_encryption(&gcm_test_case_192_3);
10679 }
10680
10681 static int
10682 test_AES_GCM_auth_encryption_test_case_192_4(void)
10683 {
10684         return test_authenticated_encryption(&gcm_test_case_192_4);
10685 }
10686
10687 static int
10688 test_AES_GCM_auth_encryption_test_case_192_5(void)
10689 {
10690         return test_authenticated_encryption(&gcm_test_case_192_5);
10691 }
10692
10693 static int
10694 test_AES_GCM_auth_encryption_test_case_192_6(void)
10695 {
10696         return test_authenticated_encryption(&gcm_test_case_192_6);
10697 }
10698
10699 static int
10700 test_AES_GCM_auth_encryption_test_case_192_7(void)
10701 {
10702         return test_authenticated_encryption(&gcm_test_case_192_7);
10703 }
10704
10705 static int
10706 test_AES_GCM_auth_encryption_test_case_256_1(void)
10707 {
10708         return test_authenticated_encryption(&gcm_test_case_256_1);
10709 }
10710
10711 static int
10712 test_AES_GCM_auth_encryption_test_case_256_2(void)
10713 {
10714         return test_authenticated_encryption(&gcm_test_case_256_2);
10715 }
10716
10717 static int
10718 test_AES_GCM_auth_encryption_test_case_256_3(void)
10719 {
10720         return test_authenticated_encryption(&gcm_test_case_256_3);
10721 }
10722
10723 static int
10724 test_AES_GCM_auth_encryption_test_case_256_4(void)
10725 {
10726         return test_authenticated_encryption(&gcm_test_case_256_4);
10727 }
10728
10729 static int
10730 test_AES_GCM_auth_encryption_test_case_256_5(void)
10731 {
10732         return test_authenticated_encryption(&gcm_test_case_256_5);
10733 }
10734
10735 static int
10736 test_AES_GCM_auth_encryption_test_case_256_6(void)
10737 {
10738         return test_authenticated_encryption(&gcm_test_case_256_6);
10739 }
10740
10741 static int
10742 test_AES_GCM_auth_encryption_test_case_256_7(void)
10743 {
10744         return test_authenticated_encryption(&gcm_test_case_256_7);
10745 }
10746
10747 static int
10748 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10749 {
10750         return test_authenticated_encryption(&gcm_test_case_aad_1);
10751 }
10752
10753 static int
10754 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10755 {
10756         return test_authenticated_encryption(&gcm_test_case_aad_2);
10757 }
10758
10759 static int
10760 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10761 {
10762         struct aead_test_data tdata;
10763         int res;
10764
10765         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10766         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10767         tdata.iv.data[0] += 1;
10768         res = test_authenticated_encryption(&tdata);
10769         if (res == TEST_SKIPPED)
10770                 return res;
10771         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10772         return TEST_SUCCESS;
10773 }
10774
10775 static int
10776 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10777 {
10778         struct aead_test_data tdata;
10779         int res;
10780
10781         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10782         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10783         tdata.plaintext.data[0] += 1;
10784         res = test_authenticated_encryption(&tdata);
10785         if (res == TEST_SKIPPED)
10786                 return res;
10787         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10788         return TEST_SUCCESS;
10789 }
10790
10791 static int
10792 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10793 {
10794         struct aead_test_data tdata;
10795         int res;
10796
10797         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10798         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10799         tdata.ciphertext.data[0] += 1;
10800         res = test_authenticated_encryption(&tdata);
10801         if (res == TEST_SKIPPED)
10802                 return res;
10803         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10804         return TEST_SUCCESS;
10805 }
10806
10807 static int
10808 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10809 {
10810         struct aead_test_data tdata;
10811         int res;
10812
10813         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10814         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10815         tdata.aad.len += 1;
10816         res = test_authenticated_encryption(&tdata);
10817         if (res == TEST_SKIPPED)
10818                 return res;
10819         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10820         return TEST_SUCCESS;
10821 }
10822
10823 static int
10824 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10825 {
10826         struct aead_test_data tdata;
10827         uint8_t aad[gcm_test_case_7.aad.len];
10828         int res;
10829
10830         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10831         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10832         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10833         aad[0] += 1;
10834         tdata.aad.data = aad;
10835         res = test_authenticated_encryption(&tdata);
10836         if (res == TEST_SKIPPED)
10837                 return res;
10838         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10839         return TEST_SUCCESS;
10840 }
10841
10842 static int
10843 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10844 {
10845         struct aead_test_data tdata;
10846         int res;
10847
10848         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10849         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10850         tdata.auth_tag.data[0] += 1;
10851         res = test_authenticated_encryption(&tdata);
10852         if (res == TEST_SKIPPED)
10853                 return res;
10854         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10855         return TEST_SUCCESS;
10856 }
10857
10858 static int
10859 test_authenticated_decryption(const struct aead_test_data *tdata)
10860 {
10861         struct crypto_testsuite_params *ts_params = &testsuite_params;
10862         struct crypto_unittest_params *ut_params = &unittest_params;
10863
10864         int retval;
10865         uint8_t *plaintext;
10866         uint32_t i;
10867         struct rte_cryptodev_info dev_info;
10868
10869         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10870         uint64_t feat_flags = dev_info.feature_flags;
10871
10872         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10873                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10874                 printf("Device doesn't support RAW data-path APIs.\n");
10875                 return TEST_SKIPPED;
10876         }
10877
10878         /* Verify the capabilities */
10879         struct rte_cryptodev_sym_capability_idx cap_idx;
10880         const struct rte_cryptodev_symmetric_capability *capability;
10881         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10882         cap_idx.algo.aead = tdata->algo;
10883         capability = rte_cryptodev_sym_capability_get(
10884                         ts_params->valid_devs[0], &cap_idx);
10885         if (capability == NULL)
10886                 return TEST_SKIPPED;
10887         if (rte_cryptodev_sym_capability_check_aead(
10888                         capability, tdata->key.len, tdata->auth_tag.len,
10889                         tdata->aad.len, tdata->iv.len))
10890                 return TEST_SKIPPED;
10891
10892         /* Create AEAD session */
10893         retval = create_aead_session(ts_params->valid_devs[0],
10894                         tdata->algo,
10895                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10896                         tdata->key.data, tdata->key.len,
10897                         tdata->aad.len, tdata->auth_tag.len,
10898                         tdata->iv.len);
10899         if (retval < 0)
10900                 return retval;
10901
10902         /* alloc mbuf and set payload */
10903         if (tdata->aad.len > MBUF_SIZE) {
10904                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10905                 /* Populate full size of add data */
10906                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10907                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10908         } else
10909                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10910
10911         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10912                         rte_pktmbuf_tailroom(ut_params->ibuf));
10913
10914         /* Create AEAD operation */
10915         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10916         if (retval < 0)
10917                 return retval;
10918
10919         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10920
10921         ut_params->op->sym->m_src = ut_params->ibuf;
10922
10923         /* Process crypto operation */
10924         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10925                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10926         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10927                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10928                                 ut_params->op, 0, 0, 0, 0);
10929         else
10930                 TEST_ASSERT_NOT_NULL(
10931                         process_crypto_request(ts_params->valid_devs[0],
10932                         ut_params->op), "failed to process sym crypto op");
10933
10934         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10935                         "crypto op processing failed");
10936
10937         if (ut_params->op->sym->m_dst)
10938                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10939                                 uint8_t *);
10940         else
10941                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10942                                 uint8_t *,
10943                                 ut_params->op->sym->cipher.data.offset);
10944
10945         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10946
10947         /* Validate obuf */
10948         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10949                         plaintext,
10950                         tdata->plaintext.data,
10951                         tdata->plaintext.len,
10952                         "Plaintext data not as expected");
10953
10954         TEST_ASSERT_EQUAL(ut_params->op->status,
10955                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10956                         "Authentication failed");
10957
10958         return 0;
10959 }
10960
10961 static int
10962 test_AES_GCM_authenticated_decryption_test_case_1(void)
10963 {
10964         return test_authenticated_decryption(&gcm_test_case_1);
10965 }
10966
10967 static int
10968 test_AES_GCM_authenticated_decryption_test_case_2(void)
10969 {
10970         return test_authenticated_decryption(&gcm_test_case_2);
10971 }
10972
10973 static int
10974 test_AES_GCM_authenticated_decryption_test_case_3(void)
10975 {
10976         return test_authenticated_decryption(&gcm_test_case_3);
10977 }
10978
10979 static int
10980 test_AES_GCM_authenticated_decryption_test_case_4(void)
10981 {
10982         return test_authenticated_decryption(&gcm_test_case_4);
10983 }
10984
10985 static int
10986 test_AES_GCM_authenticated_decryption_test_case_5(void)
10987 {
10988         return test_authenticated_decryption(&gcm_test_case_5);
10989 }
10990
10991 static int
10992 test_AES_GCM_authenticated_decryption_test_case_6(void)
10993 {
10994         return test_authenticated_decryption(&gcm_test_case_6);
10995 }
10996
10997 static int
10998 test_AES_GCM_authenticated_decryption_test_case_7(void)
10999 {
11000         return test_authenticated_decryption(&gcm_test_case_7);
11001 }
11002
11003 static int
11004 test_AES_GCM_authenticated_decryption_test_case_8(void)
11005 {
11006         return test_authenticated_decryption(&gcm_test_case_8);
11007 }
11008
11009 static int
11010 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
11011 {
11012         return test_authenticated_decryption(&gcm_J0_test_case_1);
11013 }
11014
11015 static int
11016 test_AES_GCM_auth_decryption_test_case_192_1(void)
11017 {
11018         return test_authenticated_decryption(&gcm_test_case_192_1);
11019 }
11020
11021 static int
11022 test_AES_GCM_auth_decryption_test_case_192_2(void)
11023 {
11024         return test_authenticated_decryption(&gcm_test_case_192_2);
11025 }
11026
11027 static int
11028 test_AES_GCM_auth_decryption_test_case_192_3(void)
11029 {
11030         return test_authenticated_decryption(&gcm_test_case_192_3);
11031 }
11032
11033 static int
11034 test_AES_GCM_auth_decryption_test_case_192_4(void)
11035 {
11036         return test_authenticated_decryption(&gcm_test_case_192_4);
11037 }
11038
11039 static int
11040 test_AES_GCM_auth_decryption_test_case_192_5(void)
11041 {
11042         return test_authenticated_decryption(&gcm_test_case_192_5);
11043 }
11044
11045 static int
11046 test_AES_GCM_auth_decryption_test_case_192_6(void)
11047 {
11048         return test_authenticated_decryption(&gcm_test_case_192_6);
11049 }
11050
11051 static int
11052 test_AES_GCM_auth_decryption_test_case_192_7(void)
11053 {
11054         return test_authenticated_decryption(&gcm_test_case_192_7);
11055 }
11056
11057 static int
11058 test_AES_GCM_auth_decryption_test_case_256_1(void)
11059 {
11060         return test_authenticated_decryption(&gcm_test_case_256_1);
11061 }
11062
11063 static int
11064 test_AES_GCM_auth_decryption_test_case_256_2(void)
11065 {
11066         return test_authenticated_decryption(&gcm_test_case_256_2);
11067 }
11068
11069 static int
11070 test_AES_GCM_auth_decryption_test_case_256_3(void)
11071 {
11072         return test_authenticated_decryption(&gcm_test_case_256_3);
11073 }
11074
11075 static int
11076 test_AES_GCM_auth_decryption_test_case_256_4(void)
11077 {
11078         return test_authenticated_decryption(&gcm_test_case_256_4);
11079 }
11080
11081 static int
11082 test_AES_GCM_auth_decryption_test_case_256_5(void)
11083 {
11084         return test_authenticated_decryption(&gcm_test_case_256_5);
11085 }
11086
11087 static int
11088 test_AES_GCM_auth_decryption_test_case_256_6(void)
11089 {
11090         return test_authenticated_decryption(&gcm_test_case_256_6);
11091 }
11092
11093 static int
11094 test_AES_GCM_auth_decryption_test_case_256_7(void)
11095 {
11096         return test_authenticated_decryption(&gcm_test_case_256_7);
11097 }
11098
11099 static int
11100 test_AES_GCM_auth_decryption_test_case_aad_1(void)
11101 {
11102         return test_authenticated_decryption(&gcm_test_case_aad_1);
11103 }
11104
11105 static int
11106 test_AES_GCM_auth_decryption_test_case_aad_2(void)
11107 {
11108         return test_authenticated_decryption(&gcm_test_case_aad_2);
11109 }
11110
11111 static int
11112 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
11113 {
11114         struct aead_test_data tdata;
11115         int res;
11116
11117         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11118         tdata.iv.data[0] += 1;
11119         res = test_authenticated_decryption(&tdata);
11120         if (res == TEST_SKIPPED)
11121                 return res;
11122         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11123         return TEST_SUCCESS;
11124 }
11125
11126 static int
11127 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
11128 {
11129         struct aead_test_data tdata;
11130         int res;
11131
11132         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
11133         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11134         tdata.plaintext.data[0] += 1;
11135         res = test_authenticated_decryption(&tdata);
11136         if (res == TEST_SKIPPED)
11137                 return res;
11138         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11139         return TEST_SUCCESS;
11140 }
11141
11142 static int
11143 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
11144 {
11145         struct aead_test_data tdata;
11146         int res;
11147
11148         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11149         tdata.ciphertext.data[0] += 1;
11150         res = test_authenticated_decryption(&tdata);
11151         if (res == TEST_SKIPPED)
11152                 return res;
11153         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11154         return TEST_SUCCESS;
11155 }
11156
11157 static int
11158 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
11159 {
11160         struct aead_test_data tdata;
11161         int res;
11162
11163         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11164         tdata.aad.len += 1;
11165         res = test_authenticated_decryption(&tdata);
11166         if (res == TEST_SKIPPED)
11167                 return res;
11168         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11169         return TEST_SUCCESS;
11170 }
11171
11172 static int
11173 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
11174 {
11175         struct aead_test_data tdata;
11176         uint8_t aad[gcm_test_case_7.aad.len];
11177         int res;
11178
11179         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11180         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
11181         aad[0] += 1;
11182         tdata.aad.data = aad;
11183         res = test_authenticated_decryption(&tdata);
11184         if (res == TEST_SKIPPED)
11185                 return res;
11186         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11187         return TEST_SUCCESS;
11188 }
11189
11190 static int
11191 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
11192 {
11193         struct aead_test_data tdata;
11194         int res;
11195
11196         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11197         tdata.auth_tag.data[0] += 1;
11198         res = test_authenticated_decryption(&tdata);
11199         if (res == TEST_SKIPPED)
11200                 return res;
11201         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
11202         return TEST_SUCCESS;
11203 }
11204
11205 static int
11206 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
11207 {
11208         struct crypto_testsuite_params *ts_params = &testsuite_params;
11209         struct crypto_unittest_params *ut_params = &unittest_params;
11210
11211         int retval;
11212         uint8_t *ciphertext, *auth_tag;
11213         uint16_t plaintext_pad_len;
11214         struct rte_cryptodev_info dev_info;
11215
11216         /* Verify the capabilities */
11217         struct rte_cryptodev_sym_capability_idx cap_idx;
11218         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11219         cap_idx.algo.aead = tdata->algo;
11220         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11221                         &cap_idx) == NULL)
11222                 return TEST_SKIPPED;
11223
11224         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11225         uint64_t feat_flags = dev_info.feature_flags;
11226
11227         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11228                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
11229                 return TEST_SKIPPED;
11230
11231         /* not supported with CPU crypto */
11232         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11233                 return TEST_SKIPPED;
11234
11235         /* Create AEAD session */
11236         retval = create_aead_session(ts_params->valid_devs[0],
11237                         tdata->algo,
11238                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11239                         tdata->key.data, tdata->key.len,
11240                         tdata->aad.len, tdata->auth_tag.len,
11241                         tdata->iv.len);
11242         if (retval < 0)
11243                 return retval;
11244
11245         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11246         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11247
11248         /* clear mbuf payload */
11249         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11250                         rte_pktmbuf_tailroom(ut_params->ibuf));
11251         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11252                         rte_pktmbuf_tailroom(ut_params->obuf));
11253
11254         /* Create AEAD operation */
11255         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11256         if (retval < 0)
11257                 return retval;
11258
11259         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11260
11261         ut_params->op->sym->m_src = ut_params->ibuf;
11262         ut_params->op->sym->m_dst = ut_params->obuf;
11263
11264         /* Process crypto operation */
11265         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11266                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11267                         ut_params->op, 0, 0, 0, 0);
11268         else
11269                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11270                         ut_params->op), "failed to process sym crypto op");
11271
11272         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11273                         "crypto op processing failed");
11274
11275         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11276
11277         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11278                         ut_params->op->sym->cipher.data.offset);
11279         auth_tag = ciphertext + plaintext_pad_len;
11280
11281         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11282         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11283
11284         /* Validate obuf */
11285         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11286                         ciphertext,
11287                         tdata->ciphertext.data,
11288                         tdata->ciphertext.len,
11289                         "Ciphertext data not as expected");
11290
11291         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11292                         auth_tag,
11293                         tdata->auth_tag.data,
11294                         tdata->auth_tag.len,
11295                         "Generated auth tag not as expected");
11296
11297         return 0;
11298
11299 }
11300
11301 static int
11302 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
11303 {
11304         return test_authenticated_encryption_oop(&gcm_test_case_5);
11305 }
11306
11307 static int
11308 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
11309 {
11310         struct crypto_testsuite_params *ts_params = &testsuite_params;
11311         struct crypto_unittest_params *ut_params = &unittest_params;
11312
11313         int retval;
11314         uint8_t *plaintext;
11315         struct rte_cryptodev_info dev_info;
11316
11317         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11318         uint64_t feat_flags = dev_info.feature_flags;
11319
11320         /* Verify the capabilities */
11321         struct rte_cryptodev_sym_capability_idx cap_idx;
11322         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11323         cap_idx.algo.aead = tdata->algo;
11324         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11325                         &cap_idx) == NULL)
11326                 return TEST_SKIPPED;
11327
11328         /* not supported with CPU crypto and raw data-path APIs*/
11329         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
11330                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
11331                 return TEST_SKIPPED;
11332
11333         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11334                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11335                 printf("Device does not support RAW data-path APIs.\n");
11336                 return TEST_SKIPPED;
11337         }
11338
11339         /* Create AEAD session */
11340         retval = create_aead_session(ts_params->valid_devs[0],
11341                         tdata->algo,
11342                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11343                         tdata->key.data, tdata->key.len,
11344                         tdata->aad.len, tdata->auth_tag.len,
11345                         tdata->iv.len);
11346         if (retval < 0)
11347                 return retval;
11348
11349         /* alloc mbuf and set payload */
11350         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11351         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11352
11353         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11354                         rte_pktmbuf_tailroom(ut_params->ibuf));
11355         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11356                         rte_pktmbuf_tailroom(ut_params->obuf));
11357
11358         /* Create AEAD operation */
11359         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11360         if (retval < 0)
11361                 return retval;
11362
11363         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11364
11365         ut_params->op->sym->m_src = ut_params->ibuf;
11366         ut_params->op->sym->m_dst = ut_params->obuf;
11367
11368         /* Process crypto operation */
11369         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11370                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11371                                 ut_params->op, 0, 0, 0, 0);
11372         else
11373                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11374                         ut_params->op), "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         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11380                         ut_params->op->sym->cipher.data.offset);
11381
11382         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11383
11384         /* Validate obuf */
11385         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11386                         plaintext,
11387                         tdata->plaintext.data,
11388                         tdata->plaintext.len,
11389                         "Plaintext data not as expected");
11390
11391         TEST_ASSERT_EQUAL(ut_params->op->status,
11392                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11393                         "Authentication failed");
11394         return 0;
11395 }
11396
11397 static int
11398 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
11399 {
11400         return test_authenticated_decryption_oop(&gcm_test_case_5);
11401 }
11402
11403 static int
11404 test_authenticated_encryption_sessionless(
11405                 const struct aead_test_data *tdata)
11406 {
11407         struct crypto_testsuite_params *ts_params = &testsuite_params;
11408         struct crypto_unittest_params *ut_params = &unittest_params;
11409
11410         int retval;
11411         uint8_t *ciphertext, *auth_tag;
11412         uint16_t plaintext_pad_len;
11413         uint8_t key[tdata->key.len + 1];
11414         struct rte_cryptodev_info dev_info;
11415
11416         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11417         uint64_t feat_flags = dev_info.feature_flags;
11418
11419         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11420                 printf("Device doesn't support Sessionless ops.\n");
11421                 return TEST_SKIPPED;
11422         }
11423
11424         /* not supported with CPU crypto */
11425         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11426                 return TEST_SKIPPED;
11427
11428         /* Verify the capabilities */
11429         struct rte_cryptodev_sym_capability_idx cap_idx;
11430         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11431         cap_idx.algo.aead = tdata->algo;
11432         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11433                         &cap_idx) == NULL)
11434                 return TEST_SKIPPED;
11435
11436         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11437
11438         /* clear mbuf payload */
11439         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11440                         rte_pktmbuf_tailroom(ut_params->ibuf));
11441
11442         /* Create AEAD operation */
11443         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11444         if (retval < 0)
11445                 return retval;
11446
11447         /* Create GCM xform */
11448         memcpy(key, tdata->key.data, tdata->key.len);
11449         retval = create_aead_xform(ut_params->op,
11450                         tdata->algo,
11451                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11452                         key, tdata->key.len,
11453                         tdata->aad.len, tdata->auth_tag.len,
11454                         tdata->iv.len);
11455         if (retval < 0)
11456                 return retval;
11457
11458         ut_params->op->sym->m_src = ut_params->ibuf;
11459
11460         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11461                         RTE_CRYPTO_OP_SESSIONLESS,
11462                         "crypto op session type not sessionless");
11463
11464         /* Process crypto operation */
11465         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11466                         ut_params->op), "failed to process sym crypto op");
11467
11468         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11469
11470         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11471                         "crypto op status not success");
11472
11473         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11474
11475         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11476                         ut_params->op->sym->cipher.data.offset);
11477         auth_tag = ciphertext + plaintext_pad_len;
11478
11479         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11480         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11481
11482         /* Validate obuf */
11483         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11484                         ciphertext,
11485                         tdata->ciphertext.data,
11486                         tdata->ciphertext.len,
11487                         "Ciphertext data not as expected");
11488
11489         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11490                         auth_tag,
11491                         tdata->auth_tag.data,
11492                         tdata->auth_tag.len,
11493                         "Generated auth tag not as expected");
11494
11495         return 0;
11496
11497 }
11498
11499 static int
11500 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11501 {
11502         return test_authenticated_encryption_sessionless(
11503                         &gcm_test_case_5);
11504 }
11505
11506 static int
11507 test_authenticated_decryption_sessionless(
11508                 const struct aead_test_data *tdata)
11509 {
11510         struct crypto_testsuite_params *ts_params = &testsuite_params;
11511         struct crypto_unittest_params *ut_params = &unittest_params;
11512
11513         int retval;
11514         uint8_t *plaintext;
11515         uint8_t key[tdata->key.len + 1];
11516         struct rte_cryptodev_info dev_info;
11517
11518         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11519         uint64_t feat_flags = dev_info.feature_flags;
11520
11521         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11522                 printf("Device doesn't support Sessionless ops.\n");
11523                 return TEST_SKIPPED;
11524         }
11525
11526         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11527                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11528                 printf("Device doesn't support RAW data-path APIs.\n");
11529                 return TEST_SKIPPED;
11530         }
11531
11532         /* not supported with CPU crypto */
11533         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11534                 return TEST_SKIPPED;
11535
11536         /* Verify the capabilities */
11537         struct rte_cryptodev_sym_capability_idx cap_idx;
11538         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11539         cap_idx.algo.aead = tdata->algo;
11540         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11541                         &cap_idx) == NULL)
11542                 return TEST_SKIPPED;
11543
11544         /* alloc mbuf and set payload */
11545         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11546
11547         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11548                         rte_pktmbuf_tailroom(ut_params->ibuf));
11549
11550         /* Create AEAD operation */
11551         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11552         if (retval < 0)
11553                 return retval;
11554
11555         /* Create AEAD xform */
11556         memcpy(key, tdata->key.data, tdata->key.len);
11557         retval = create_aead_xform(ut_params->op,
11558                         tdata->algo,
11559                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11560                         key, tdata->key.len,
11561                         tdata->aad.len, tdata->auth_tag.len,
11562                         tdata->iv.len);
11563         if (retval < 0)
11564                 return retval;
11565
11566         ut_params->op->sym->m_src = ut_params->ibuf;
11567
11568         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11569                         RTE_CRYPTO_OP_SESSIONLESS,
11570                         "crypto op session type not sessionless");
11571
11572         /* Process crypto operation */
11573         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11574                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11575                                 ut_params->op, 0, 0, 0, 0);
11576         else
11577                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11578                         ts_params->valid_devs[0], ut_params->op),
11579                                 "failed to process sym crypto op");
11580
11581         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11582
11583         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11584                         "crypto op status not success");
11585
11586         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11587                         ut_params->op->sym->cipher.data.offset);
11588
11589         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11590
11591         /* Validate obuf */
11592         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11593                         plaintext,
11594                         tdata->plaintext.data,
11595                         tdata->plaintext.len,
11596                         "Plaintext data not as expected");
11597
11598         TEST_ASSERT_EQUAL(ut_params->op->status,
11599                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11600                         "Authentication failed");
11601         return 0;
11602 }
11603
11604 static int
11605 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11606 {
11607         return test_authenticated_decryption_sessionless(
11608                         &gcm_test_case_5);
11609 }
11610
11611 static int
11612 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11613 {
11614         return test_authenticated_encryption(&ccm_test_case_128_1);
11615 }
11616
11617 static int
11618 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11619 {
11620         return test_authenticated_encryption(&ccm_test_case_128_2);
11621 }
11622
11623 static int
11624 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11625 {
11626         return test_authenticated_encryption(&ccm_test_case_128_3);
11627 }
11628
11629 static int
11630 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11631 {
11632         return test_authenticated_decryption(&ccm_test_case_128_1);
11633 }
11634
11635 static int
11636 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11637 {
11638         return test_authenticated_decryption(&ccm_test_case_128_2);
11639 }
11640
11641 static int
11642 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11643 {
11644         return test_authenticated_decryption(&ccm_test_case_128_3);
11645 }
11646
11647 static int
11648 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11649 {
11650         return test_authenticated_encryption(&ccm_test_case_192_1);
11651 }
11652
11653 static int
11654 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11655 {
11656         return test_authenticated_encryption(&ccm_test_case_192_2);
11657 }
11658
11659 static int
11660 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11661 {
11662         return test_authenticated_encryption(&ccm_test_case_192_3);
11663 }
11664
11665 static int
11666 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11667 {
11668         return test_authenticated_decryption(&ccm_test_case_192_1);
11669 }
11670
11671 static int
11672 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11673 {
11674         return test_authenticated_decryption(&ccm_test_case_192_2);
11675 }
11676
11677 static int
11678 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11679 {
11680         return test_authenticated_decryption(&ccm_test_case_192_3);
11681 }
11682
11683 static int
11684 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11685 {
11686         return test_authenticated_encryption(&ccm_test_case_256_1);
11687 }
11688
11689 static int
11690 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11691 {
11692         return test_authenticated_encryption(&ccm_test_case_256_2);
11693 }
11694
11695 static int
11696 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11697 {
11698         return test_authenticated_encryption(&ccm_test_case_256_3);
11699 }
11700
11701 static int
11702 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11703 {
11704         return test_authenticated_decryption(&ccm_test_case_256_1);
11705 }
11706
11707 static int
11708 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11709 {
11710         return test_authenticated_decryption(&ccm_test_case_256_2);
11711 }
11712
11713 static int
11714 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11715 {
11716         return test_authenticated_decryption(&ccm_test_case_256_3);
11717 }
11718
11719 static int
11720 test_stats(void)
11721 {
11722         struct crypto_testsuite_params *ts_params = &testsuite_params;
11723         struct rte_cryptodev_stats stats;
11724
11725         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11726                 return TEST_SKIPPED;
11727
11728         /* Verify the capabilities */
11729         struct rte_cryptodev_sym_capability_idx cap_idx;
11730         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11731         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11732         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11733                         &cap_idx) == NULL)
11734                 return TEST_SKIPPED;
11735         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11736         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11737         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11738                         &cap_idx) == NULL)
11739                 return TEST_SKIPPED;
11740
11741         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11742                         == -ENOTSUP)
11743                 return TEST_SKIPPED;
11744
11745         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11746         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11747                         &stats) == -ENODEV),
11748                 "rte_cryptodev_stats_get invalid dev failed");
11749         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11750                 "rte_cryptodev_stats_get invalid Param failed");
11751
11752         /* Test expected values */
11753         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11754         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11755                         &stats),
11756                 "rte_cryptodev_stats_get failed");
11757         TEST_ASSERT((stats.enqueued_count == 1),
11758                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11759         TEST_ASSERT((stats.dequeued_count == 1),
11760                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11761         TEST_ASSERT((stats.enqueue_err_count == 0),
11762                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11763         TEST_ASSERT((stats.dequeue_err_count == 0),
11764                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11765
11766         /* invalid device but should ignore and not reset device stats*/
11767         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11768         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11769                         &stats),
11770                 "rte_cryptodev_stats_get failed");
11771         TEST_ASSERT((stats.enqueued_count == 1),
11772                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11773
11774         /* check that a valid reset clears stats */
11775         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11776         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11777                         &stats),
11778                                           "rte_cryptodev_stats_get failed");
11779         TEST_ASSERT((stats.enqueued_count == 0),
11780                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11781         TEST_ASSERT((stats.dequeued_count == 0),
11782                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11783
11784         return TEST_SUCCESS;
11785 }
11786
11787 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11788                                    struct crypto_unittest_params *ut_params,
11789                                    enum rte_crypto_auth_operation op,
11790                                    const struct HMAC_MD5_vector *test_case)
11791 {
11792         uint8_t key[64];
11793         int status;
11794
11795         memcpy(key, test_case->key.data, test_case->key.len);
11796
11797         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11798         ut_params->auth_xform.next = NULL;
11799         ut_params->auth_xform.auth.op = op;
11800
11801         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11802
11803         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11804         ut_params->auth_xform.auth.key.length = test_case->key.len;
11805         ut_params->auth_xform.auth.key.data = key;
11806
11807         ut_params->sess = rte_cryptodev_sym_session_create(
11808                         ts_params->session_mpool);
11809         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11810         if (ut_params->sess == NULL)
11811                 return TEST_FAILED;
11812
11813         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11814                         ut_params->sess, &ut_params->auth_xform,
11815                         ts_params->session_priv_mpool);
11816         if (status == -ENOTSUP)
11817                 return TEST_SKIPPED;
11818
11819         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11820
11821         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11822                         rte_pktmbuf_tailroom(ut_params->ibuf));
11823
11824         return 0;
11825 }
11826
11827 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11828                               const struct HMAC_MD5_vector *test_case,
11829                               uint8_t **plaintext)
11830 {
11831         uint16_t plaintext_pad_len;
11832
11833         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11834
11835         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11836                                 16);
11837
11838         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11839                         plaintext_pad_len);
11840         memcpy(*plaintext, test_case->plaintext.data,
11841                         test_case->plaintext.len);
11842
11843         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11844                         ut_params->ibuf, MD5_DIGEST_LEN);
11845         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11846                         "no room to append digest");
11847         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11848                         ut_params->ibuf, plaintext_pad_len);
11849
11850         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11851                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11852                            test_case->auth_tag.len);
11853         }
11854
11855         sym_op->auth.data.offset = 0;
11856         sym_op->auth.data.length = test_case->plaintext.len;
11857
11858         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11859         ut_params->op->sym->m_src = ut_params->ibuf;
11860
11861         return 0;
11862 }
11863
11864 static int
11865 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11866 {
11867         uint16_t plaintext_pad_len;
11868         uint8_t *plaintext, *auth_tag;
11869
11870         struct crypto_testsuite_params *ts_params = &testsuite_params;
11871         struct crypto_unittest_params *ut_params = &unittest_params;
11872         struct rte_cryptodev_info dev_info;
11873
11874         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11875         uint64_t feat_flags = dev_info.feature_flags;
11876
11877         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11878                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11879                 printf("Device doesn't support RAW data-path APIs.\n");
11880                 return TEST_SKIPPED;
11881         }
11882
11883         /* Verify the capabilities */
11884         struct rte_cryptodev_sym_capability_idx cap_idx;
11885         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11886         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11887         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11888                         &cap_idx) == NULL)
11889                 return TEST_SKIPPED;
11890
11891         if (MD5_HMAC_create_session(ts_params, ut_params,
11892                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11893                 return TEST_FAILED;
11894
11895         /* Generate Crypto op data structure */
11896         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11897                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11898         TEST_ASSERT_NOT_NULL(ut_params->op,
11899                         "Failed to allocate symmetric crypto operation struct");
11900
11901         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11902                                 16);
11903
11904         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11905                 return TEST_FAILED;
11906
11907         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11908                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11909                         ut_params->op);
11910         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11911                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11912                                 ut_params->op, 0, 1, 0, 0);
11913         else
11914                 TEST_ASSERT_NOT_NULL(
11915                         process_crypto_request(ts_params->valid_devs[0],
11916                                 ut_params->op),
11917                                 "failed to process sym crypto op");
11918
11919         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11920                         "crypto op processing failed");
11921
11922         if (ut_params->op->sym->m_dst) {
11923                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11924                                 uint8_t *, plaintext_pad_len);
11925         } else {
11926                 auth_tag = plaintext + plaintext_pad_len;
11927         }
11928
11929         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11930                         auth_tag,
11931                         test_case->auth_tag.data,
11932                         test_case->auth_tag.len,
11933                         "HMAC_MD5 generated tag not as expected");
11934
11935         return TEST_SUCCESS;
11936 }
11937
11938 static int
11939 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11940 {
11941         uint8_t *plaintext;
11942
11943         struct crypto_testsuite_params *ts_params = &testsuite_params;
11944         struct crypto_unittest_params *ut_params = &unittest_params;
11945         struct rte_cryptodev_info dev_info;
11946
11947         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11948         uint64_t feat_flags = dev_info.feature_flags;
11949
11950         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11951                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11952                 printf("Device doesn't support RAW data-path APIs.\n");
11953                 return TEST_SKIPPED;
11954         }
11955
11956         /* Verify the capabilities */
11957         struct rte_cryptodev_sym_capability_idx cap_idx;
11958         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11959         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11960         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11961                         &cap_idx) == NULL)
11962                 return TEST_SKIPPED;
11963
11964         if (MD5_HMAC_create_session(ts_params, ut_params,
11965                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11966                 return TEST_FAILED;
11967         }
11968
11969         /* Generate Crypto op data structure */
11970         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11971                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11972         TEST_ASSERT_NOT_NULL(ut_params->op,
11973                         "Failed to allocate symmetric crypto operation struct");
11974
11975         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11976                 return TEST_FAILED;
11977
11978         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11979                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11980                         ut_params->op);
11981         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11982                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11983                                 ut_params->op, 0, 1, 0, 0);
11984         else
11985                 TEST_ASSERT_NOT_NULL(
11986                         process_crypto_request(ts_params->valid_devs[0],
11987                                 ut_params->op),
11988                                 "failed to process sym crypto op");
11989
11990         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11991                         "HMAC_MD5 crypto op processing failed");
11992
11993         return TEST_SUCCESS;
11994 }
11995
11996 static int
11997 test_MD5_HMAC_generate_case_1(void)
11998 {
11999         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
12000 }
12001
12002 static int
12003 test_MD5_HMAC_verify_case_1(void)
12004 {
12005         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
12006 }
12007
12008 static int
12009 test_MD5_HMAC_generate_case_2(void)
12010 {
12011         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
12012 }
12013
12014 static int
12015 test_MD5_HMAC_verify_case_2(void)
12016 {
12017         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
12018 }
12019
12020 static int
12021 test_multi_session(void)
12022 {
12023         struct crypto_testsuite_params *ts_params = &testsuite_params;
12024         struct crypto_unittest_params *ut_params = &unittest_params;
12025
12026         struct rte_cryptodev_info dev_info;
12027         struct rte_cryptodev_sym_session **sessions;
12028
12029         uint16_t i;
12030         int status;
12031
12032         /* Verify the capabilities */
12033         struct rte_cryptodev_sym_capability_idx cap_idx;
12034         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12035         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12036         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12037                         &cap_idx) == NULL)
12038                 return TEST_SKIPPED;
12039         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12040         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12041         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12042                         &cap_idx) == NULL)
12043                 return TEST_SKIPPED;
12044
12045         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
12046                         aes_cbc_key, hmac_sha512_key);
12047
12048
12049         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12050
12051         sessions = rte_malloc(NULL,
12052                         sizeof(struct rte_cryptodev_sym_session *) *
12053                         (MAX_NB_SESSIONS + 1), 0);
12054
12055         /* Create multiple crypto sessions*/
12056         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12057
12058                 sessions[i] = rte_cryptodev_sym_session_create(
12059                                 ts_params->session_mpool);
12060                 TEST_ASSERT_NOT_NULL(sessions[i],
12061                                 "Session creation failed at session number %u",
12062                                 i);
12063
12064                 status = rte_cryptodev_sym_session_init(
12065                                 ts_params->valid_devs[0],
12066                                 sessions[i], &ut_params->auth_xform,
12067                                 ts_params->session_priv_mpool);
12068                 if (status == -ENOTSUP)
12069                         return TEST_SKIPPED;
12070
12071                 /* Attempt to send a request on each session */
12072                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
12073                         sessions[i],
12074                         ut_params,
12075                         ts_params,
12076                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
12077                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
12078                         aes_cbc_iv),
12079                         "Failed to perform decrypt on request number %u.", i);
12080                 /* free crypto operation structure */
12081                 if (ut_params->op)
12082                         rte_crypto_op_free(ut_params->op);
12083
12084                 /*
12085                  * free mbuf - both obuf and ibuf are usually the same,
12086                  * so check if they point at the same address is necessary,
12087                  * to avoid freeing the mbuf twice.
12088                  */
12089                 if (ut_params->obuf) {
12090                         rte_pktmbuf_free(ut_params->obuf);
12091                         if (ut_params->ibuf == ut_params->obuf)
12092                                 ut_params->ibuf = 0;
12093                         ut_params->obuf = 0;
12094                 }
12095                 if (ut_params->ibuf) {
12096                         rte_pktmbuf_free(ut_params->ibuf);
12097                         ut_params->ibuf = 0;
12098                 }
12099         }
12100
12101         sessions[i] = NULL;
12102         /* Next session create should fail */
12103         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12104                         sessions[i], &ut_params->auth_xform,
12105                         ts_params->session_priv_mpool);
12106         TEST_ASSERT_NULL(sessions[i],
12107                         "Session creation succeeded unexpectedly!");
12108
12109         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12110                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12111                                 sessions[i]);
12112                 rte_cryptodev_sym_session_free(sessions[i]);
12113         }
12114
12115         rte_free(sessions);
12116
12117         return TEST_SUCCESS;
12118 }
12119
12120 struct multi_session_params {
12121         struct crypto_unittest_params ut_params;
12122         uint8_t *cipher_key;
12123         uint8_t *hmac_key;
12124         const uint8_t *cipher;
12125         const uint8_t *digest;
12126         uint8_t *iv;
12127 };
12128
12129 #define MB_SESSION_NUMBER 3
12130
12131 static int
12132 test_multi_session_random_usage(void)
12133 {
12134         struct crypto_testsuite_params *ts_params = &testsuite_params;
12135         struct rte_cryptodev_info dev_info;
12136         struct rte_cryptodev_sym_session **sessions;
12137         uint32_t i, j;
12138         struct multi_session_params ut_paramz[] = {
12139
12140                 {
12141                         .cipher_key = ms_aes_cbc_key0,
12142                         .hmac_key = ms_hmac_key0,
12143                         .cipher = ms_aes_cbc_cipher0,
12144                         .digest = ms_hmac_digest0,
12145                         .iv = ms_aes_cbc_iv0
12146                 },
12147                 {
12148                         .cipher_key = ms_aes_cbc_key1,
12149                         .hmac_key = ms_hmac_key1,
12150                         .cipher = ms_aes_cbc_cipher1,
12151                         .digest = ms_hmac_digest1,
12152                         .iv = ms_aes_cbc_iv1
12153                 },
12154                 {
12155                         .cipher_key = ms_aes_cbc_key2,
12156                         .hmac_key = ms_hmac_key2,
12157                         .cipher = ms_aes_cbc_cipher2,
12158                         .digest = ms_hmac_digest2,
12159                         .iv = ms_aes_cbc_iv2
12160                 },
12161
12162         };
12163         int status;
12164
12165         /* Verify the capabilities */
12166         struct rte_cryptodev_sym_capability_idx cap_idx;
12167         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12168         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12169         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12170                         &cap_idx) == NULL)
12171                 return TEST_SKIPPED;
12172         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12173         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12174         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12175                         &cap_idx) == NULL)
12176                 return TEST_SKIPPED;
12177
12178         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12179
12180         sessions = rte_malloc(NULL,
12181                         (sizeof(struct rte_cryptodev_sym_session *)
12182                                         * MAX_NB_SESSIONS) + 1, 0);
12183
12184         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12185                 sessions[i] = rte_cryptodev_sym_session_create(
12186                                 ts_params->session_mpool);
12187                 TEST_ASSERT_NOT_NULL(sessions[i],
12188                                 "Session creation failed at session number %u",
12189                                 i);
12190
12191                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
12192                                 sizeof(struct crypto_unittest_params));
12193
12194                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
12195                                 &ut_paramz[i].ut_params,
12196                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
12197
12198                 /* Create multiple crypto sessions*/
12199                 status = rte_cryptodev_sym_session_init(
12200                                 ts_params->valid_devs[0],
12201                                 sessions[i],
12202                                 &ut_paramz[i].ut_params.auth_xform,
12203                                 ts_params->session_priv_mpool);
12204
12205                 if (status == -ENOTSUP)
12206                         return TEST_SKIPPED;
12207
12208                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12209         }
12210
12211         srand(time(NULL));
12212         for (i = 0; i < 40000; i++) {
12213
12214                 j = rand() % MB_SESSION_NUMBER;
12215
12216                 TEST_ASSERT_SUCCESS(
12217                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
12218                                         sessions[j],
12219                                         &ut_paramz[j].ut_params,
12220                                         ts_params, ut_paramz[j].cipher,
12221                                         ut_paramz[j].digest,
12222                                         ut_paramz[j].iv),
12223                         "Failed to perform decrypt on request number %u.", i);
12224
12225                 if (ut_paramz[j].ut_params.op)
12226                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
12227
12228                 /*
12229                  * free mbuf - both obuf and ibuf are usually the same,
12230                  * so check if they point at the same address is necessary,
12231                  * to avoid freeing the mbuf twice.
12232                  */
12233                 if (ut_paramz[j].ut_params.obuf) {
12234                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
12235                         if (ut_paramz[j].ut_params.ibuf
12236                                         == ut_paramz[j].ut_params.obuf)
12237                                 ut_paramz[j].ut_params.ibuf = 0;
12238                         ut_paramz[j].ut_params.obuf = 0;
12239                 }
12240                 if (ut_paramz[j].ut_params.ibuf) {
12241                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
12242                         ut_paramz[j].ut_params.ibuf = 0;
12243                 }
12244         }
12245
12246         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12247                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12248                                 sessions[i]);
12249                 rte_cryptodev_sym_session_free(sessions[i]);
12250         }
12251
12252         rte_free(sessions);
12253
12254         return TEST_SUCCESS;
12255 }
12256
12257 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
12258                         0xab, 0xab, 0xab, 0xab,
12259                         0xab, 0xab, 0xab, 0xab,
12260                         0xab, 0xab, 0xab, 0xab};
12261
12262 static int
12263 test_null_invalid_operation(void)
12264 {
12265         struct crypto_testsuite_params *ts_params = &testsuite_params;
12266         struct crypto_unittest_params *ut_params = &unittest_params;
12267         int ret;
12268
12269         /* This test is for NULL PMD only */
12270         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12271                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12272                 return TEST_SKIPPED;
12273
12274         /* Setup Cipher Parameters */
12275         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12276         ut_params->cipher_xform.next = NULL;
12277
12278         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
12279         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12280
12281         ut_params->sess = rte_cryptodev_sym_session_create(
12282                         ts_params->session_mpool);
12283
12284         /* Create Crypto session*/
12285         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12286                         ut_params->sess, &ut_params->cipher_xform,
12287                         ts_params->session_priv_mpool);
12288         TEST_ASSERT(ret < 0,
12289                         "Session creation succeeded unexpectedly");
12290
12291
12292         /* Setup HMAC Parameters */
12293         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12294         ut_params->auth_xform.next = NULL;
12295
12296         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
12297         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12298
12299         ut_params->sess = rte_cryptodev_sym_session_create(
12300                         ts_params->session_mpool);
12301
12302         /* Create Crypto session*/
12303         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12304                         ut_params->sess, &ut_params->auth_xform,
12305                         ts_params->session_priv_mpool);
12306         TEST_ASSERT(ret < 0,
12307                         "Session creation succeeded unexpectedly");
12308
12309         return TEST_SUCCESS;
12310 }
12311
12312
12313 #define NULL_BURST_LENGTH (32)
12314
12315 static int
12316 test_null_burst_operation(void)
12317 {
12318         struct crypto_testsuite_params *ts_params = &testsuite_params;
12319         struct crypto_unittest_params *ut_params = &unittest_params;
12320         int status;
12321
12322         unsigned i, burst_len = NULL_BURST_LENGTH;
12323
12324         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
12325         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
12326
12327         /* This test is for NULL PMD only */
12328         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12329                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12330                 return TEST_SKIPPED;
12331
12332         /* Setup Cipher Parameters */
12333         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12334         ut_params->cipher_xform.next = &ut_params->auth_xform;
12335
12336         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
12337         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12338
12339         /* Setup HMAC Parameters */
12340         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12341         ut_params->auth_xform.next = NULL;
12342
12343         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
12344         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12345
12346         ut_params->sess = rte_cryptodev_sym_session_create(
12347                         ts_params->session_mpool);
12348         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12349
12350         /* Create Crypto session*/
12351         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12352                         ut_params->sess, &ut_params->cipher_xform,
12353                         ts_params->session_priv_mpool);
12354
12355         if (status == -ENOTSUP)
12356                 return TEST_SKIPPED;
12357
12358         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12359
12360         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
12361                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
12362                         burst_len, "failed to generate burst of crypto ops");
12363
12364         /* Generate an operation for each mbuf in burst */
12365         for (i = 0; i < burst_len; i++) {
12366                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12367
12368                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
12369
12370                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
12371                                 sizeof(unsigned));
12372                 *data = i;
12373
12374                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
12375
12376                 burst[i]->sym->m_src = m;
12377         }
12378
12379         /* Process crypto operation */
12380         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
12381                         0, burst, burst_len),
12382                         burst_len,
12383                         "Error enqueuing burst");
12384
12385         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
12386                         0, burst_dequeued, burst_len),
12387                         burst_len,
12388                         "Error dequeuing burst");
12389
12390
12391         for (i = 0; i < burst_len; i++) {
12392                 TEST_ASSERT_EQUAL(
12393                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
12394                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
12395                                         uint32_t *),
12396                         "data not as expected");
12397
12398                 rte_pktmbuf_free(burst[i]->sym->m_src);
12399                 rte_crypto_op_free(burst[i]);
12400         }
12401
12402         return TEST_SUCCESS;
12403 }
12404
12405 static uint16_t
12406 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12407                   uint16_t nb_ops, void *user_param)
12408 {
12409         RTE_SET_USED(dev_id);
12410         RTE_SET_USED(qp_id);
12411         RTE_SET_USED(ops);
12412         RTE_SET_USED(user_param);
12413
12414         printf("crypto enqueue callback called\n");
12415         return nb_ops;
12416 }
12417
12418 static uint16_t
12419 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12420                   uint16_t nb_ops, void *user_param)
12421 {
12422         RTE_SET_USED(dev_id);
12423         RTE_SET_USED(qp_id);
12424         RTE_SET_USED(ops);
12425         RTE_SET_USED(user_param);
12426
12427         printf("crypto dequeue callback called\n");
12428         return nb_ops;
12429 }
12430
12431 /*
12432  * Thread using enqueue/dequeue callback with RCU.
12433  */
12434 static int
12435 test_enqdeq_callback_thread(void *arg)
12436 {
12437         RTE_SET_USED(arg);
12438         /* DP thread calls rte_cryptodev_enqueue_burst()/
12439          * rte_cryptodev_dequeue_burst() and invokes callback.
12440          */
12441         test_null_burst_operation();
12442         return 0;
12443 }
12444
12445 static int
12446 test_enq_callback_setup(void)
12447 {
12448         struct crypto_testsuite_params *ts_params = &testsuite_params;
12449         struct rte_cryptodev_info dev_info;
12450         struct rte_cryptodev_qp_conf qp_conf = {
12451                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12452         };
12453
12454         struct rte_cryptodev_cb *cb;
12455         uint16_t qp_id = 0;
12456
12457         /* Stop the device in case it's started so it can be configured */
12458         rte_cryptodev_stop(ts_params->valid_devs[0]);
12459
12460         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12461
12462         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12463                         &ts_params->conf),
12464                         "Failed to configure cryptodev %u",
12465                         ts_params->valid_devs[0]);
12466
12467         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12468         qp_conf.mp_session = ts_params->session_mpool;
12469         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12470
12471         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12472                         ts_params->valid_devs[0], qp_id, &qp_conf,
12473                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12474                         "Failed test for "
12475                         "rte_cryptodev_queue_pair_setup: num_inflights "
12476                         "%u on qp %u on cryptodev %u",
12477                         qp_conf.nb_descriptors, qp_id,
12478                         ts_params->valid_devs[0]);
12479
12480         /* Test with invalid crypto device */
12481         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
12482                         qp_id, test_enq_callback, NULL);
12483         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12484                         "cryptodev %u did not fail",
12485                         qp_id, RTE_CRYPTO_MAX_DEVS);
12486
12487         /* Test with invalid queue pair */
12488         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12489                         dev_info.max_nb_queue_pairs + 1,
12490                         test_enq_callback, NULL);
12491         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12492                         "cryptodev %u did not fail",
12493                         dev_info.max_nb_queue_pairs + 1,
12494                         ts_params->valid_devs[0]);
12495
12496         /* Test with NULL callback */
12497         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12498                         qp_id, NULL, NULL);
12499         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12500                         "cryptodev %u did not fail",
12501                         qp_id, ts_params->valid_devs[0]);
12502
12503         /* Test with valid configuration */
12504         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12505                         qp_id, test_enq_callback, NULL);
12506         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12507                         "qp %u on cryptodev %u",
12508                         qp_id, ts_params->valid_devs[0]);
12509
12510         rte_cryptodev_start(ts_params->valid_devs[0]);
12511
12512         /* Launch a thread */
12513         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12514                                 rte_get_next_lcore(-1, 1, 0));
12515
12516         /* Wait until reader exited. */
12517         rte_eal_mp_wait_lcore();
12518
12519         /* Test with invalid crypto device */
12520         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12521                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12522                         "Expected call to fail as crypto device is invalid");
12523
12524         /* Test with invalid queue pair */
12525         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12526                         ts_params->valid_devs[0],
12527                         dev_info.max_nb_queue_pairs + 1, cb),
12528                         "Expected call to fail as queue pair is invalid");
12529
12530         /* Test with NULL callback */
12531         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12532                         ts_params->valid_devs[0], qp_id, NULL),
12533                         "Expected call to fail as callback is NULL");
12534
12535         /* Test with valid configuration */
12536         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12537                         ts_params->valid_devs[0], qp_id, cb),
12538                         "Failed test to remove callback on "
12539                         "qp %u on cryptodev %u",
12540                         qp_id, ts_params->valid_devs[0]);
12541
12542         return TEST_SUCCESS;
12543 }
12544
12545 static int
12546 test_deq_callback_setup(void)
12547 {
12548         struct crypto_testsuite_params *ts_params = &testsuite_params;
12549         struct rte_cryptodev_info dev_info;
12550         struct rte_cryptodev_qp_conf qp_conf = {
12551                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12552         };
12553
12554         struct rte_cryptodev_cb *cb;
12555         uint16_t qp_id = 0;
12556
12557         /* Stop the device in case it's started so it can be configured */
12558         rte_cryptodev_stop(ts_params->valid_devs[0]);
12559
12560         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12561
12562         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12563                         &ts_params->conf),
12564                         "Failed to configure cryptodev %u",
12565                         ts_params->valid_devs[0]);
12566
12567         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12568         qp_conf.mp_session = ts_params->session_mpool;
12569         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12570
12571         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12572                         ts_params->valid_devs[0], qp_id, &qp_conf,
12573                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12574                         "Failed test for "
12575                         "rte_cryptodev_queue_pair_setup: num_inflights "
12576                         "%u on qp %u on cryptodev %u",
12577                         qp_conf.nb_descriptors, qp_id,
12578                         ts_params->valid_devs[0]);
12579
12580         /* Test with invalid crypto device */
12581         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12582                         qp_id, test_deq_callback, NULL);
12583         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12584                         "cryptodev %u did not fail",
12585                         qp_id, RTE_CRYPTO_MAX_DEVS);
12586
12587         /* Test with invalid queue pair */
12588         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12589                         dev_info.max_nb_queue_pairs + 1,
12590                         test_deq_callback, NULL);
12591         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12592                         "cryptodev %u did not fail",
12593                         dev_info.max_nb_queue_pairs + 1,
12594                         ts_params->valid_devs[0]);
12595
12596         /* Test with NULL callback */
12597         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12598                         qp_id, NULL, NULL);
12599         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12600                         "cryptodev %u did not fail",
12601                         qp_id, ts_params->valid_devs[0]);
12602
12603         /* Test with valid configuration */
12604         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12605                         qp_id, test_deq_callback, NULL);
12606         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12607                         "qp %u on cryptodev %u",
12608                         qp_id, ts_params->valid_devs[0]);
12609
12610         rte_cryptodev_start(ts_params->valid_devs[0]);
12611
12612         /* Launch a thread */
12613         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12614                                 rte_get_next_lcore(-1, 1, 0));
12615
12616         /* Wait until reader exited. */
12617         rte_eal_mp_wait_lcore();
12618
12619         /* Test with invalid crypto device */
12620         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12621                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12622                         "Expected call to fail as crypto device is invalid");
12623
12624         /* Test with invalid queue pair */
12625         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12626                         ts_params->valid_devs[0],
12627                         dev_info.max_nb_queue_pairs + 1, cb),
12628                         "Expected call to fail as queue pair is invalid");
12629
12630         /* Test with NULL callback */
12631         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12632                         ts_params->valid_devs[0], qp_id, NULL),
12633                         "Expected call to fail as callback is NULL");
12634
12635         /* Test with valid configuration */
12636         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12637                         ts_params->valid_devs[0], qp_id, cb),
12638                         "Failed test to remove callback on "
12639                         "qp %u on cryptodev %u",
12640                         qp_id, ts_params->valid_devs[0]);
12641
12642         return TEST_SUCCESS;
12643 }
12644
12645 static void
12646 generate_gmac_large_plaintext(uint8_t *data)
12647 {
12648         uint16_t i;
12649
12650         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12651                 memcpy(&data[i], &data[0], 32);
12652 }
12653
12654 static int
12655 create_gmac_operation(enum rte_crypto_auth_operation op,
12656                 const struct gmac_test_data *tdata)
12657 {
12658         struct crypto_testsuite_params *ts_params = &testsuite_params;
12659         struct crypto_unittest_params *ut_params = &unittest_params;
12660         struct rte_crypto_sym_op *sym_op;
12661
12662         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12663
12664         /* Generate Crypto op data structure */
12665         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12666                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12667         TEST_ASSERT_NOT_NULL(ut_params->op,
12668                         "Failed to allocate symmetric crypto operation struct");
12669
12670         sym_op = ut_params->op->sym;
12671
12672         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12673                         ut_params->ibuf, tdata->gmac_tag.len);
12674         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12675                         "no room to append digest");
12676
12677         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12678                         ut_params->ibuf, plaintext_pad_len);
12679
12680         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12681                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12682                                 tdata->gmac_tag.len);
12683                 debug_hexdump(stdout, "digest:",
12684                                 sym_op->auth.digest.data,
12685                                 tdata->gmac_tag.len);
12686         }
12687
12688         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12689                         uint8_t *, IV_OFFSET);
12690
12691         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12692
12693         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12694
12695         sym_op->cipher.data.length = 0;
12696         sym_op->cipher.data.offset = 0;
12697
12698         sym_op->auth.data.offset = 0;
12699         sym_op->auth.data.length = tdata->plaintext.len;
12700
12701         return 0;
12702 }
12703
12704 static int
12705 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12706                 const struct gmac_test_data *tdata,
12707                 void *digest_mem, uint64_t digest_phys)
12708 {
12709         struct crypto_testsuite_params *ts_params = &testsuite_params;
12710         struct crypto_unittest_params *ut_params = &unittest_params;
12711         struct rte_crypto_sym_op *sym_op;
12712
12713         /* Generate Crypto op data structure */
12714         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12715                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12716         TEST_ASSERT_NOT_NULL(ut_params->op,
12717                         "Failed to allocate symmetric crypto operation struct");
12718
12719         sym_op = ut_params->op->sym;
12720
12721         sym_op->auth.digest.data = digest_mem;
12722         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12723                         "no room to append digest");
12724
12725         sym_op->auth.digest.phys_addr = digest_phys;
12726
12727         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12728                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12729                                 tdata->gmac_tag.len);
12730                 debug_hexdump(stdout, "digest:",
12731                                 sym_op->auth.digest.data,
12732                                 tdata->gmac_tag.len);
12733         }
12734
12735         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12736                         uint8_t *, IV_OFFSET);
12737
12738         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12739
12740         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12741
12742         sym_op->cipher.data.length = 0;
12743         sym_op->cipher.data.offset = 0;
12744
12745         sym_op->auth.data.offset = 0;
12746         sym_op->auth.data.length = tdata->plaintext.len;
12747
12748         return 0;
12749 }
12750
12751 static int create_gmac_session(uint8_t dev_id,
12752                 const struct gmac_test_data *tdata,
12753                 enum rte_crypto_auth_operation auth_op)
12754 {
12755         uint8_t auth_key[tdata->key.len];
12756         int status;
12757
12758         struct crypto_testsuite_params *ts_params = &testsuite_params;
12759         struct crypto_unittest_params *ut_params = &unittest_params;
12760
12761         memcpy(auth_key, tdata->key.data, tdata->key.len);
12762
12763         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12764         ut_params->auth_xform.next = NULL;
12765
12766         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12767         ut_params->auth_xform.auth.op = auth_op;
12768         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12769         ut_params->auth_xform.auth.key.length = tdata->key.len;
12770         ut_params->auth_xform.auth.key.data = auth_key;
12771         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12772         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12773
12774
12775         ut_params->sess = rte_cryptodev_sym_session_create(
12776                         ts_params->session_mpool);
12777         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12778
12779         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12780                         &ut_params->auth_xform,
12781                         ts_params->session_priv_mpool);
12782
12783         return status;
12784 }
12785
12786 static int
12787 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12788 {
12789         struct crypto_testsuite_params *ts_params = &testsuite_params;
12790         struct crypto_unittest_params *ut_params = &unittest_params;
12791         struct rte_cryptodev_info dev_info;
12792
12793         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12794         uint64_t feat_flags = dev_info.feature_flags;
12795
12796         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12797                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12798                 printf("Device doesn't support RAW data-path APIs.\n");
12799                 return TEST_SKIPPED;
12800         }
12801
12802         int retval;
12803
12804         uint8_t *auth_tag, *plaintext;
12805         uint16_t plaintext_pad_len;
12806
12807         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12808                               "No GMAC length in the source data");
12809
12810         /* Verify the capabilities */
12811         struct rte_cryptodev_sym_capability_idx cap_idx;
12812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12813         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12814         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12815                         &cap_idx) == NULL)
12816                 return TEST_SKIPPED;
12817
12818         retval = create_gmac_session(ts_params->valid_devs[0],
12819                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12820
12821         if (retval == -ENOTSUP)
12822                 return TEST_SKIPPED;
12823         if (retval < 0)
12824                 return retval;
12825
12826         if (tdata->plaintext.len > MBUF_SIZE)
12827                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12828         else
12829                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12830         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12831                         "Failed to allocate input buffer in mempool");
12832
12833         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12834                         rte_pktmbuf_tailroom(ut_params->ibuf));
12835
12836         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12837         /*
12838          * Runtime generate the large plain text instead of use hard code
12839          * plain text vector. It is done to avoid create huge source file
12840          * with the test vector.
12841          */
12842         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12843                 generate_gmac_large_plaintext(tdata->plaintext.data);
12844
12845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12846                                 plaintext_pad_len);
12847         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12848
12849         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12850         debug_hexdump(stdout, "plaintext:", plaintext,
12851                         tdata->plaintext.len);
12852
12853         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12854                         tdata);
12855
12856         if (retval < 0)
12857                 return retval;
12858
12859         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12860
12861         ut_params->op->sym->m_src = ut_params->ibuf;
12862
12863         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12864                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12865                         ut_params->op);
12866         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12867                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12868                                 ut_params->op, 0, 1, 0, 0);
12869         else
12870                 TEST_ASSERT_NOT_NULL(
12871                         process_crypto_request(ts_params->valid_devs[0],
12872                         ut_params->op), "failed to process sym crypto op");
12873
12874         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12875                         "crypto op processing failed");
12876
12877         if (ut_params->op->sym->m_dst) {
12878                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12879                                 uint8_t *, plaintext_pad_len);
12880         } else {
12881                 auth_tag = plaintext + plaintext_pad_len;
12882         }
12883
12884         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12885
12886         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12887                         auth_tag,
12888                         tdata->gmac_tag.data,
12889                         tdata->gmac_tag.len,
12890                         "GMAC Generated auth tag not as expected");
12891
12892         return 0;
12893 }
12894
12895 static int
12896 test_AES_GMAC_authentication_test_case_1(void)
12897 {
12898         return test_AES_GMAC_authentication(&gmac_test_case_1);
12899 }
12900
12901 static int
12902 test_AES_GMAC_authentication_test_case_2(void)
12903 {
12904         return test_AES_GMAC_authentication(&gmac_test_case_2);
12905 }
12906
12907 static int
12908 test_AES_GMAC_authentication_test_case_3(void)
12909 {
12910         return test_AES_GMAC_authentication(&gmac_test_case_3);
12911 }
12912
12913 static int
12914 test_AES_GMAC_authentication_test_case_4(void)
12915 {
12916         return test_AES_GMAC_authentication(&gmac_test_case_4);
12917 }
12918
12919 static int
12920 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12921 {
12922         struct crypto_testsuite_params *ts_params = &testsuite_params;
12923         struct crypto_unittest_params *ut_params = &unittest_params;
12924         int retval;
12925         uint32_t plaintext_pad_len;
12926         uint8_t *plaintext;
12927         struct rte_cryptodev_info dev_info;
12928
12929         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12930         uint64_t feat_flags = dev_info.feature_flags;
12931
12932         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12933                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12934                 printf("Device doesn't support RAW data-path APIs.\n");
12935                 return TEST_SKIPPED;
12936         }
12937
12938         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12939                               "No GMAC length in the source data");
12940
12941         /* Verify the capabilities */
12942         struct rte_cryptodev_sym_capability_idx cap_idx;
12943         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12944         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12945         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12946                         &cap_idx) == NULL)
12947                 return TEST_SKIPPED;
12948
12949         retval = create_gmac_session(ts_params->valid_devs[0],
12950                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12951
12952         if (retval == -ENOTSUP)
12953                 return TEST_SKIPPED;
12954         if (retval < 0)
12955                 return retval;
12956
12957         if (tdata->plaintext.len > MBUF_SIZE)
12958                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12959         else
12960                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12961         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12962                         "Failed to allocate input buffer in mempool");
12963
12964         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12965                         rte_pktmbuf_tailroom(ut_params->ibuf));
12966
12967         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12968
12969         /*
12970          * Runtime generate the large plain text instead of use hard code
12971          * plain text vector. It is done to avoid create huge source file
12972          * with the test vector.
12973          */
12974         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12975                 generate_gmac_large_plaintext(tdata->plaintext.data);
12976
12977         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12978                                 plaintext_pad_len);
12979         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12980
12981         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12982         debug_hexdump(stdout, "plaintext:", plaintext,
12983                         tdata->plaintext.len);
12984
12985         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12986                         tdata);
12987
12988         if (retval < 0)
12989                 return retval;
12990
12991         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12992
12993         ut_params->op->sym->m_src = ut_params->ibuf;
12994
12995         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12996                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12997                         ut_params->op);
12998         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12999                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13000                                 ut_params->op, 0, 1, 0, 0);
13001         else
13002                 TEST_ASSERT_NOT_NULL(
13003                         process_crypto_request(ts_params->valid_devs[0],
13004                         ut_params->op), "failed to process sym crypto op");
13005
13006         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13007                         "crypto op processing failed");
13008
13009         return 0;
13010
13011 }
13012
13013 static int
13014 test_AES_GMAC_authentication_verify_test_case_1(void)
13015 {
13016         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
13017 }
13018
13019 static int
13020 test_AES_GMAC_authentication_verify_test_case_2(void)
13021 {
13022         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
13023 }
13024
13025 static int
13026 test_AES_GMAC_authentication_verify_test_case_3(void)
13027 {
13028         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
13029 }
13030
13031 static int
13032 test_AES_GMAC_authentication_verify_test_case_4(void)
13033 {
13034         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
13035 }
13036
13037 static int
13038 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
13039                                 uint32_t fragsz)
13040 {
13041         struct crypto_testsuite_params *ts_params = &testsuite_params;
13042         struct crypto_unittest_params *ut_params = &unittest_params;
13043         struct rte_cryptodev_info dev_info;
13044         uint64_t feature_flags;
13045         unsigned int trn_data = 0;
13046         void *digest_mem = NULL;
13047         uint32_t segs = 1;
13048         unsigned int to_trn = 0;
13049         struct rte_mbuf *buf = NULL;
13050         uint8_t *auth_tag, *plaintext;
13051         int retval;
13052
13053         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
13054                               "No GMAC length in the source data");
13055
13056         /* Verify the capabilities */
13057         struct rte_cryptodev_sym_capability_idx cap_idx;
13058         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13059         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
13060         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13061                         &cap_idx) == NULL)
13062                 return TEST_SKIPPED;
13063
13064         /* Check for any input SGL support */
13065         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13066         feature_flags = dev_info.feature_flags;
13067
13068         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
13069                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
13070                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
13071                 return TEST_SKIPPED;
13072
13073         if (fragsz > tdata->plaintext.len)
13074                 fragsz = tdata->plaintext.len;
13075
13076         uint16_t plaintext_len = fragsz;
13077
13078         retval = create_gmac_session(ts_params->valid_devs[0],
13079                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
13080
13081         if (retval == -ENOTSUP)
13082                 return TEST_SKIPPED;
13083         if (retval < 0)
13084                 return retval;
13085
13086         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13087         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13088                         "Failed to allocate input buffer in mempool");
13089
13090         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13091                         rte_pktmbuf_tailroom(ut_params->ibuf));
13092
13093         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13094                                 plaintext_len);
13095         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13096
13097         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13098
13099         trn_data += plaintext_len;
13100
13101         buf = ut_params->ibuf;
13102
13103         /*
13104          * Loop until no more fragments
13105          */
13106
13107         while (trn_data < tdata->plaintext.len) {
13108                 ++segs;
13109                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13110                                 (tdata->plaintext.len - trn_data) : fragsz;
13111
13112                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13113                 buf = buf->next;
13114
13115                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13116                                 rte_pktmbuf_tailroom(buf));
13117
13118                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13119                                 to_trn);
13120
13121                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13122                                 to_trn);
13123                 trn_data += to_trn;
13124                 if (trn_data  == tdata->plaintext.len)
13125                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13126                                         tdata->gmac_tag.len);
13127         }
13128         ut_params->ibuf->nb_segs = segs;
13129
13130         /*
13131          * Place digest at the end of the last buffer
13132          */
13133         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13134
13135         if (!digest_mem) {
13136                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13137                                 + tdata->gmac_tag.len);
13138                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13139                                 tdata->plaintext.len);
13140         }
13141
13142         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
13143                         tdata, digest_mem, digest_phys);
13144
13145         if (retval < 0)
13146                 return retval;
13147
13148         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13149
13150         ut_params->op->sym->m_src = ut_params->ibuf;
13151
13152         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13153                 return TEST_SKIPPED;
13154
13155         TEST_ASSERT_NOT_NULL(
13156                 process_crypto_request(ts_params->valid_devs[0],
13157                 ut_params->op), "failed to process sym crypto op");
13158
13159         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13160                         "crypto op processing failed");
13161
13162         auth_tag = digest_mem;
13163         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
13164         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13165                         auth_tag,
13166                         tdata->gmac_tag.data,
13167                         tdata->gmac_tag.len,
13168                         "GMAC Generated auth tag not as expected");
13169
13170         return 0;
13171 }
13172
13173 /* Segment size not multiple of block size (16B) */
13174 static int
13175 test_AES_GMAC_authentication_SGL_40B(void)
13176 {
13177         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
13178 }
13179
13180 static int
13181 test_AES_GMAC_authentication_SGL_80B(void)
13182 {
13183         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
13184 }
13185
13186 static int
13187 test_AES_GMAC_authentication_SGL_2048B(void)
13188 {
13189         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
13190 }
13191
13192 /* Segment size not multiple of block size (16B) */
13193 static int
13194 test_AES_GMAC_authentication_SGL_2047B(void)
13195 {
13196         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
13197 }
13198
13199 struct test_crypto_vector {
13200         enum rte_crypto_cipher_algorithm crypto_algo;
13201         unsigned int cipher_offset;
13202         unsigned int cipher_len;
13203
13204         struct {
13205                 uint8_t data[64];
13206                 unsigned int len;
13207         } cipher_key;
13208
13209         struct {
13210                 uint8_t data[64];
13211                 unsigned int len;
13212         } iv;
13213
13214         struct {
13215                 const uint8_t *data;
13216                 unsigned int len;
13217         } plaintext;
13218
13219         struct {
13220                 const uint8_t *data;
13221                 unsigned int len;
13222         } ciphertext;
13223
13224         enum rte_crypto_auth_algorithm auth_algo;
13225         unsigned int auth_offset;
13226
13227         struct {
13228                 uint8_t data[128];
13229                 unsigned int len;
13230         } auth_key;
13231
13232         struct {
13233                 const uint8_t *data;
13234                 unsigned int len;
13235         } aad;
13236
13237         struct {
13238                 uint8_t data[128];
13239                 unsigned int len;
13240         } digest;
13241 };
13242
13243 static const struct test_crypto_vector
13244 hmac_sha1_test_crypto_vector = {
13245         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13246         .plaintext = {
13247                 .data = plaintext_hash,
13248                 .len = 512
13249         },
13250         .auth_key = {
13251                 .data = {
13252                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13253                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13254                         0xDE, 0xF4, 0xDE, 0xAD
13255                 },
13256                 .len = 20
13257         },
13258         .digest = {
13259                 .data = {
13260                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
13261                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
13262                         0x3F, 0x91, 0x64, 0x59
13263                 },
13264                 .len = 20
13265         }
13266 };
13267
13268 static const struct test_crypto_vector
13269 aes128_gmac_test_vector = {
13270         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
13271         .plaintext = {
13272                 .data = plaintext_hash,
13273                 .len = 512
13274         },
13275         .iv = {
13276                 .data = {
13277                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13278                         0x08, 0x09, 0x0A, 0x0B
13279                 },
13280                 .len = 12
13281         },
13282         .auth_key = {
13283                 .data = {
13284                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13285                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
13286                 },
13287                 .len = 16
13288         },
13289         .digest = {
13290                 .data = {
13291                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
13292                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
13293                 },
13294                 .len = 16
13295         }
13296 };
13297
13298 static const struct test_crypto_vector
13299 aes128cbc_hmac_sha1_test_vector = {
13300         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13301         .cipher_offset = 0,
13302         .cipher_len = 512,
13303         .cipher_key = {
13304                 .data = {
13305                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13306                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13307                 },
13308                 .len = 16
13309         },
13310         .iv = {
13311                 .data = {
13312                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13313                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13314                 },
13315                 .len = 16
13316         },
13317         .plaintext = {
13318                 .data = plaintext_hash,
13319                 .len = 512
13320         },
13321         .ciphertext = {
13322                 .data = ciphertext512_aes128cbc,
13323                 .len = 512
13324         },
13325         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13326         .auth_offset = 0,
13327         .auth_key = {
13328                 .data = {
13329                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13330                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13331                         0xDE, 0xF4, 0xDE, 0xAD
13332                 },
13333                 .len = 20
13334         },
13335         .digest = {
13336                 .data = {
13337                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
13338                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13339                         0x18, 0x8C, 0x1D, 0x32
13340                 },
13341                 .len = 20
13342         }
13343 };
13344
13345 static const struct test_crypto_vector
13346 aes128cbc_hmac_sha1_aad_test_vector = {
13347         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13348         .cipher_offset = 8,
13349         .cipher_len = 496,
13350         .cipher_key = {
13351                 .data = {
13352                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13353                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13354                 },
13355                 .len = 16
13356         },
13357         .iv = {
13358                 .data = {
13359                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13360                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13361                 },
13362                 .len = 16
13363         },
13364         .plaintext = {
13365                 .data = plaintext_hash,
13366                 .len = 512
13367         },
13368         .ciphertext = {
13369                 .data = ciphertext512_aes128cbc_aad,
13370                 .len = 512
13371         },
13372         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13373         .auth_offset = 0,
13374         .auth_key = {
13375                 .data = {
13376                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13377                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13378                         0xDE, 0xF4, 0xDE, 0xAD
13379                 },
13380                 .len = 20
13381         },
13382         .digest = {
13383                 .data = {
13384                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
13385                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
13386                         0x62, 0x0F, 0xFB, 0x10
13387                 },
13388                 .len = 20
13389         }
13390 };
13391
13392 static void
13393 data_corruption(uint8_t *data)
13394 {
13395         data[0] += 1;
13396 }
13397
13398 static void
13399 tag_corruption(uint8_t *data, unsigned int tag_offset)
13400 {
13401         data[tag_offset] += 1;
13402 }
13403
13404 static int
13405 create_auth_session(struct crypto_unittest_params *ut_params,
13406                 uint8_t dev_id,
13407                 const struct test_crypto_vector *reference,
13408                 enum rte_crypto_auth_operation auth_op)
13409 {
13410         struct crypto_testsuite_params *ts_params = &testsuite_params;
13411         uint8_t auth_key[reference->auth_key.len + 1];
13412         int status;
13413
13414         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13415
13416         /* Setup Authentication Parameters */
13417         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13418         ut_params->auth_xform.auth.op = auth_op;
13419         ut_params->auth_xform.next = NULL;
13420         ut_params->auth_xform.auth.algo = reference->auth_algo;
13421         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13422         ut_params->auth_xform.auth.key.data = auth_key;
13423         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13424
13425         /* Create Crypto session*/
13426         ut_params->sess = rte_cryptodev_sym_session_create(
13427                         ts_params->session_mpool);
13428         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13429
13430         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13431                                 &ut_params->auth_xform,
13432                                 ts_params->session_priv_mpool);
13433
13434         return status;
13435 }
13436
13437 static int
13438 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
13439                 uint8_t dev_id,
13440                 const struct test_crypto_vector *reference,
13441                 enum rte_crypto_auth_operation auth_op,
13442                 enum rte_crypto_cipher_operation cipher_op)
13443 {
13444         struct crypto_testsuite_params *ts_params = &testsuite_params;
13445         uint8_t cipher_key[reference->cipher_key.len + 1];
13446         uint8_t auth_key[reference->auth_key.len + 1];
13447         int status;
13448
13449         memcpy(cipher_key, reference->cipher_key.data,
13450                         reference->cipher_key.len);
13451         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13452
13453         /* Setup Authentication Parameters */
13454         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13455         ut_params->auth_xform.auth.op = auth_op;
13456         ut_params->auth_xform.auth.algo = reference->auth_algo;
13457         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13458         ut_params->auth_xform.auth.key.data = auth_key;
13459         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13460
13461         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
13462                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
13463                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
13464         } else {
13465                 ut_params->auth_xform.next = &ut_params->cipher_xform;
13466
13467                 /* Setup Cipher Parameters */
13468                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13469                 ut_params->cipher_xform.next = NULL;
13470                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13471                 ut_params->cipher_xform.cipher.op = cipher_op;
13472                 ut_params->cipher_xform.cipher.key.data = cipher_key;
13473                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13474                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13475                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13476         }
13477
13478         /* Create Crypto session*/
13479         ut_params->sess = rte_cryptodev_sym_session_create(
13480                         ts_params->session_mpool);
13481         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13482
13483         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13484                                 &ut_params->auth_xform,
13485                                 ts_params->session_priv_mpool);
13486
13487         return status;
13488 }
13489
13490 static int
13491 create_auth_operation(struct crypto_testsuite_params *ts_params,
13492                 struct crypto_unittest_params *ut_params,
13493                 const struct test_crypto_vector *reference,
13494                 unsigned int auth_generate)
13495 {
13496         /* Generate Crypto op data structure */
13497         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13498                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13499         TEST_ASSERT_NOT_NULL(ut_params->op,
13500                         "Failed to allocate pktmbuf offload");
13501
13502         /* Set crypto operation data parameters */
13503         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13504
13505         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13506
13507         /* set crypto operation source mbuf */
13508         sym_op->m_src = ut_params->ibuf;
13509
13510         /* digest */
13511         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13512                         ut_params->ibuf, reference->digest.len);
13513
13514         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13515                         "no room to append auth tag");
13516
13517         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13518                         ut_params->ibuf, reference->plaintext.len);
13519
13520         if (auth_generate)
13521                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13522         else
13523                 memcpy(sym_op->auth.digest.data,
13524                                 reference->digest.data,
13525                                 reference->digest.len);
13526
13527         debug_hexdump(stdout, "digest:",
13528                         sym_op->auth.digest.data,
13529                         reference->digest.len);
13530
13531         sym_op->auth.data.length = reference->plaintext.len;
13532         sym_op->auth.data.offset = 0;
13533
13534         return 0;
13535 }
13536
13537 static int
13538 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13539                 struct crypto_unittest_params *ut_params,
13540                 const struct test_crypto_vector *reference,
13541                 unsigned int auth_generate)
13542 {
13543         /* Generate Crypto op data structure */
13544         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13545                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13546         TEST_ASSERT_NOT_NULL(ut_params->op,
13547                         "Failed to allocate pktmbuf offload");
13548
13549         /* Set crypto operation data parameters */
13550         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13551
13552         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13553
13554         /* set crypto operation source mbuf */
13555         sym_op->m_src = ut_params->ibuf;
13556
13557         /* digest */
13558         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13559                         ut_params->ibuf, reference->digest.len);
13560
13561         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13562                         "no room to append auth tag");
13563
13564         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13565                         ut_params->ibuf, reference->ciphertext.len);
13566
13567         if (auth_generate)
13568                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13569         else
13570                 memcpy(sym_op->auth.digest.data,
13571                                 reference->digest.data,
13572                                 reference->digest.len);
13573
13574         debug_hexdump(stdout, "digest:",
13575                         sym_op->auth.digest.data,
13576                         reference->digest.len);
13577
13578         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13579                         reference->iv.data, reference->iv.len);
13580
13581         sym_op->cipher.data.length = 0;
13582         sym_op->cipher.data.offset = 0;
13583
13584         sym_op->auth.data.length = reference->plaintext.len;
13585         sym_op->auth.data.offset = 0;
13586
13587         return 0;
13588 }
13589
13590 static int
13591 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13592                 struct crypto_unittest_params *ut_params,
13593                 const struct test_crypto_vector *reference,
13594                 unsigned int auth_generate)
13595 {
13596         /* Generate Crypto op data structure */
13597         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13598                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13599         TEST_ASSERT_NOT_NULL(ut_params->op,
13600                         "Failed to allocate pktmbuf offload");
13601
13602         /* Set crypto operation data parameters */
13603         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13604
13605         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13606
13607         /* set crypto operation source mbuf */
13608         sym_op->m_src = ut_params->ibuf;
13609
13610         /* digest */
13611         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13612                         ut_params->ibuf, reference->digest.len);
13613
13614         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13615                         "no room to append auth tag");
13616
13617         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13618                         ut_params->ibuf, reference->ciphertext.len);
13619
13620         if (auth_generate)
13621                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13622         else
13623                 memcpy(sym_op->auth.digest.data,
13624                                 reference->digest.data,
13625                                 reference->digest.len);
13626
13627         debug_hexdump(stdout, "digest:",
13628                         sym_op->auth.digest.data,
13629                         reference->digest.len);
13630
13631         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13632                         reference->iv.data, reference->iv.len);
13633
13634         sym_op->cipher.data.length = reference->cipher_len;
13635         sym_op->cipher.data.offset = reference->cipher_offset;
13636
13637         sym_op->auth.data.length = reference->plaintext.len;
13638         sym_op->auth.data.offset = reference->auth_offset;
13639
13640         return 0;
13641 }
13642
13643 static int
13644 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13645                 struct crypto_unittest_params *ut_params,
13646                 const struct test_crypto_vector *reference)
13647 {
13648         return create_auth_operation(ts_params, ut_params, reference, 0);
13649 }
13650
13651 static int
13652 create_auth_verify_GMAC_operation(
13653                 struct crypto_testsuite_params *ts_params,
13654                 struct crypto_unittest_params *ut_params,
13655                 const struct test_crypto_vector *reference)
13656 {
13657         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13658 }
13659
13660 static int
13661 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13662                 struct crypto_unittest_params *ut_params,
13663                 const struct test_crypto_vector *reference)
13664 {
13665         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13666 }
13667
13668 static int
13669 test_authentication_verify_fail_when_data_corruption(
13670                 struct crypto_testsuite_params *ts_params,
13671                 struct crypto_unittest_params *ut_params,
13672                 const struct test_crypto_vector *reference,
13673                 unsigned int data_corrupted)
13674 {
13675         int retval;
13676
13677         uint8_t *plaintext;
13678         struct rte_cryptodev_info dev_info;
13679
13680         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13681         uint64_t feat_flags = dev_info.feature_flags;
13682
13683         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13684                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13685                 printf("Device doesn't support RAW data-path APIs.\n");
13686                 return TEST_SKIPPED;
13687         }
13688
13689         /* Verify the capabilities */
13690         struct rte_cryptodev_sym_capability_idx cap_idx;
13691         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13692         cap_idx.algo.auth = reference->auth_algo;
13693         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13694                         &cap_idx) == NULL)
13695                 return TEST_SKIPPED;
13696
13697
13698         /* Create session */
13699         retval = create_auth_session(ut_params,
13700                         ts_params->valid_devs[0],
13701                         reference,
13702                         RTE_CRYPTO_AUTH_OP_VERIFY);
13703
13704         if (retval == -ENOTSUP)
13705                 return TEST_SKIPPED;
13706         if (retval < 0)
13707                 return retval;
13708
13709         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13710         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13711                         "Failed to allocate input buffer in mempool");
13712
13713         /* clear mbuf payload */
13714         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13715                         rte_pktmbuf_tailroom(ut_params->ibuf));
13716
13717         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13718                         reference->plaintext.len);
13719         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13720         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13721
13722         debug_hexdump(stdout, "plaintext:", plaintext,
13723                 reference->plaintext.len);
13724
13725         /* Create operation */
13726         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13727
13728         if (retval < 0)
13729                 return retval;
13730
13731         if (data_corrupted)
13732                 data_corruption(plaintext);
13733         else
13734                 tag_corruption(plaintext, reference->plaintext.len);
13735
13736         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13737                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13738                         ut_params->op);
13739                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13740                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13741                         "authentication not failed");
13742         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13743                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13744                                 ut_params->op, 0, 1, 0, 0);
13745         else {
13746                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13747                         ut_params->op);
13748         }
13749         if (ut_params->op == NULL)
13750                 return 0;
13751         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13752                 return 0;
13753
13754         return -1;
13755 }
13756
13757 static int
13758 test_authentication_verify_GMAC_fail_when_corruption(
13759                 struct crypto_testsuite_params *ts_params,
13760                 struct crypto_unittest_params *ut_params,
13761                 const struct test_crypto_vector *reference,
13762                 unsigned int data_corrupted)
13763 {
13764         int retval;
13765         uint8_t *plaintext;
13766         struct rte_cryptodev_info dev_info;
13767
13768         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13769         uint64_t feat_flags = dev_info.feature_flags;
13770
13771         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13772                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13773                 printf("Device doesn't support RAW data-path APIs.\n");
13774                 return TEST_SKIPPED;
13775         }
13776
13777         /* Verify the capabilities */
13778         struct rte_cryptodev_sym_capability_idx cap_idx;
13779         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13780         cap_idx.algo.auth = reference->auth_algo;
13781         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13782                         &cap_idx) == NULL)
13783                 return TEST_SKIPPED;
13784
13785         /* Create session */
13786         retval = create_auth_cipher_session(ut_params,
13787                         ts_params->valid_devs[0],
13788                         reference,
13789                         RTE_CRYPTO_AUTH_OP_VERIFY,
13790                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13791         if (retval < 0)
13792                 return retval;
13793
13794         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13795         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13796                         "Failed to allocate input buffer in mempool");
13797
13798         /* clear mbuf payload */
13799         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13800                         rte_pktmbuf_tailroom(ut_params->ibuf));
13801
13802         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13803                         reference->plaintext.len);
13804         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13805         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13806
13807         debug_hexdump(stdout, "plaintext:", plaintext,
13808                 reference->plaintext.len);
13809
13810         /* Create operation */
13811         retval = create_auth_verify_GMAC_operation(ts_params,
13812                         ut_params,
13813                         reference);
13814
13815         if (retval < 0)
13816                 return retval;
13817
13818         if (data_corrupted)
13819                 data_corruption(plaintext);
13820         else
13821                 tag_corruption(plaintext, reference->aad.len);
13822
13823         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13824                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13825                         ut_params->op);
13826                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13827                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13828                         "authentication not failed");
13829         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13830                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13831                                 ut_params->op, 0, 1, 0, 0);
13832         else {
13833                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13834                         ut_params->op);
13835                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13836         }
13837
13838         return 0;
13839 }
13840
13841 static int
13842 test_authenticated_decryption_fail_when_corruption(
13843                 struct crypto_testsuite_params *ts_params,
13844                 struct crypto_unittest_params *ut_params,
13845                 const struct test_crypto_vector *reference,
13846                 unsigned int data_corrupted)
13847 {
13848         int retval;
13849
13850         uint8_t *ciphertext;
13851         struct rte_cryptodev_info dev_info;
13852
13853         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13854         uint64_t feat_flags = dev_info.feature_flags;
13855
13856         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13857                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13858                 printf("Device doesn't support RAW data-path APIs.\n");
13859                 return TEST_SKIPPED;
13860         }
13861
13862         /* Verify the capabilities */
13863         struct rte_cryptodev_sym_capability_idx cap_idx;
13864         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13865         cap_idx.algo.auth = reference->auth_algo;
13866         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13867                         &cap_idx) == NULL)
13868                 return TEST_SKIPPED;
13869         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13870         cap_idx.algo.cipher = reference->crypto_algo;
13871         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13872                         &cap_idx) == NULL)
13873                 return TEST_SKIPPED;
13874
13875         /* Create session */
13876         retval = create_auth_cipher_session(ut_params,
13877                         ts_params->valid_devs[0],
13878                         reference,
13879                         RTE_CRYPTO_AUTH_OP_VERIFY,
13880                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13881
13882         if (retval == -ENOTSUP)
13883                 return TEST_SKIPPED;
13884         if (retval < 0)
13885                 return retval;
13886
13887         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13888         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13889                         "Failed to allocate input buffer in mempool");
13890
13891         /* clear mbuf payload */
13892         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13893                         rte_pktmbuf_tailroom(ut_params->ibuf));
13894
13895         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13896                         reference->ciphertext.len);
13897         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13898         memcpy(ciphertext, reference->ciphertext.data,
13899                         reference->ciphertext.len);
13900
13901         /* Create operation */
13902         retval = create_cipher_auth_verify_operation(ts_params,
13903                         ut_params,
13904                         reference);
13905
13906         if (retval < 0)
13907                 return retval;
13908
13909         if (data_corrupted)
13910                 data_corruption(ciphertext);
13911         else
13912                 tag_corruption(ciphertext, reference->ciphertext.len);
13913
13914         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13915                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13916                         ut_params->op);
13917                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13918                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13919                         "authentication not failed");
13920         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13921                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13922                                 ut_params->op, 1, 1, 0, 0);
13923         else {
13924                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13925                         ut_params->op);
13926                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13927         }
13928
13929         return 0;
13930 }
13931
13932 static int
13933 test_authenticated_encrypt_with_esn(
13934                 struct crypto_testsuite_params *ts_params,
13935                 struct crypto_unittest_params *ut_params,
13936                 const struct test_crypto_vector *reference)
13937 {
13938         int retval;
13939
13940         uint8_t *authciphertext, *plaintext, *auth_tag;
13941         uint16_t plaintext_pad_len;
13942         uint8_t cipher_key[reference->cipher_key.len + 1];
13943         uint8_t auth_key[reference->auth_key.len + 1];
13944         struct rte_cryptodev_info dev_info;
13945         int status;
13946
13947         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13948         uint64_t feat_flags = dev_info.feature_flags;
13949
13950         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13951                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13952                 printf("Device doesn't support RAW data-path APIs.\n");
13953                 return TEST_SKIPPED;
13954         }
13955
13956         /* Verify the capabilities */
13957         struct rte_cryptodev_sym_capability_idx cap_idx;
13958         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13959         cap_idx.algo.auth = reference->auth_algo;
13960         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13961                         &cap_idx) == NULL)
13962                 return TEST_SKIPPED;
13963         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13964         cap_idx.algo.cipher = reference->crypto_algo;
13965         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13966                         &cap_idx) == NULL)
13967                 return TEST_SKIPPED;
13968
13969         /* Create session */
13970         memcpy(cipher_key, reference->cipher_key.data,
13971                         reference->cipher_key.len);
13972         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13973
13974         /* Setup Cipher Parameters */
13975         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13976         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13977         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13978         ut_params->cipher_xform.cipher.key.data = cipher_key;
13979         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13980         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13981         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13982
13983         ut_params->cipher_xform.next = &ut_params->auth_xform;
13984
13985         /* Setup Authentication Parameters */
13986         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13987         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13988         ut_params->auth_xform.auth.algo = reference->auth_algo;
13989         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13990         ut_params->auth_xform.auth.key.data = auth_key;
13991         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13992         ut_params->auth_xform.next = NULL;
13993
13994         /* Create Crypto session*/
13995         ut_params->sess = rte_cryptodev_sym_session_create(
13996                         ts_params->session_mpool);
13997         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13998
13999         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
14000                                 ut_params->sess,
14001                                 &ut_params->cipher_xform,
14002                                 ts_params->session_priv_mpool);
14003
14004         if (status == -ENOTSUP)
14005                 return TEST_SKIPPED;
14006
14007         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
14008
14009         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14010         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
14011                         "Failed to allocate input buffer in mempool");
14012
14013         /* clear mbuf payload */
14014         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14015                         rte_pktmbuf_tailroom(ut_params->ibuf));
14016
14017         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14018                         reference->plaintext.len);
14019         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
14020         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
14021
14022         /* Create operation */
14023         retval = create_cipher_auth_operation(ts_params,
14024                         ut_params,
14025                         reference, 0);
14026
14027         if (retval < 0)
14028                 return retval;
14029
14030         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14031                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14032                         ut_params->op);
14033         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14034                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14035                                 ut_params->op, 1, 1, 0, 0);
14036         else
14037                 ut_params->op = process_crypto_request(
14038                         ts_params->valid_devs[0], ut_params->op);
14039
14040         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
14041
14042         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14043                         "crypto op processing failed");
14044
14045         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
14046
14047         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
14048                         ut_params->op->sym->auth.data.offset);
14049         auth_tag = authciphertext + plaintext_pad_len;
14050         debug_hexdump(stdout, "ciphertext:", authciphertext,
14051                         reference->ciphertext.len);
14052         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
14053
14054         /* Validate obuf */
14055         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14056                         authciphertext,
14057                         reference->ciphertext.data,
14058                         reference->ciphertext.len,
14059                         "Ciphertext data not as expected");
14060
14061         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14062                         auth_tag,
14063                         reference->digest.data,
14064                         reference->digest.len,
14065                         "Generated digest not as expected");
14066
14067         return TEST_SUCCESS;
14068
14069 }
14070
14071 static int
14072 test_authenticated_decrypt_with_esn(
14073                 struct crypto_testsuite_params *ts_params,
14074                 struct crypto_unittest_params *ut_params,
14075                 const struct test_crypto_vector *reference)
14076 {
14077         int retval;
14078
14079         uint8_t *ciphertext;
14080         uint8_t cipher_key[reference->cipher_key.len + 1];
14081         uint8_t auth_key[reference->auth_key.len + 1];
14082         struct rte_cryptodev_info dev_info;
14083
14084         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14085         uint64_t feat_flags = dev_info.feature_flags;
14086
14087         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14088                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14089                 printf("Device doesn't support RAW data-path APIs.\n");
14090                 return TEST_SKIPPED;
14091         }
14092
14093         /* Verify the capabilities */
14094         struct rte_cryptodev_sym_capability_idx cap_idx;
14095         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14096         cap_idx.algo.auth = reference->auth_algo;
14097         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14098                         &cap_idx) == NULL)
14099                 return TEST_SKIPPED;
14100         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14101         cap_idx.algo.cipher = reference->crypto_algo;
14102         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14103                         &cap_idx) == NULL)
14104                 return TEST_SKIPPED;
14105
14106         /* Create session */
14107         memcpy(cipher_key, reference->cipher_key.data,
14108                         reference->cipher_key.len);
14109         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
14110
14111         /* Setup Authentication Parameters */
14112         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14113         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
14114         ut_params->auth_xform.auth.algo = reference->auth_algo;
14115         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
14116         ut_params->auth_xform.auth.key.data = auth_key;
14117         ut_params->auth_xform.auth.digest_length = reference->digest.len;
14118         ut_params->auth_xform.next = &ut_params->cipher_xform;
14119
14120         /* Setup Cipher Parameters */
14121         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14122         ut_params->cipher_xform.next = NULL;
14123         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
14124         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
14125         ut_params->cipher_xform.cipher.key.data = cipher_key;
14126         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
14127         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
14128         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
14129
14130         /* Create Crypto session*/
14131         ut_params->sess = rte_cryptodev_sym_session_create(
14132                         ts_params->session_mpool);
14133         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
14134
14135         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
14136                                 ut_params->sess,
14137                                 &ut_params->auth_xform,
14138                                 ts_params->session_priv_mpool);
14139
14140         if (retval == -ENOTSUP)
14141                 return TEST_SKIPPED;
14142
14143         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
14144
14145         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14146         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
14147                         "Failed to allocate input buffer in mempool");
14148
14149         /* clear mbuf payload */
14150         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14151                         rte_pktmbuf_tailroom(ut_params->ibuf));
14152
14153         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14154                         reference->ciphertext.len);
14155         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
14156         memcpy(ciphertext, reference->ciphertext.data,
14157                         reference->ciphertext.len);
14158
14159         /* Create operation */
14160         retval = create_cipher_auth_verify_operation(ts_params,
14161                         ut_params,
14162                         reference);
14163
14164         if (retval < 0)
14165                 return retval;
14166
14167         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14168                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14169                         ut_params->op);
14170         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14171                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14172                                 ut_params->op, 1, 1, 0, 0);
14173         else
14174                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
14175                         ut_params->op);
14176
14177         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
14178         TEST_ASSERT_EQUAL(ut_params->op->status,
14179                         RTE_CRYPTO_OP_STATUS_SUCCESS,
14180                         "crypto op processing passed");
14181
14182         ut_params->obuf = ut_params->op->sym->m_src;
14183         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
14184
14185         return 0;
14186 }
14187
14188 static int
14189 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
14190                 const struct aead_test_data *tdata,
14191                 void *digest_mem, uint64_t digest_phys)
14192 {
14193         struct crypto_testsuite_params *ts_params = &testsuite_params;
14194         struct crypto_unittest_params *ut_params = &unittest_params;
14195
14196         const unsigned int auth_tag_len = tdata->auth_tag.len;
14197         const unsigned int iv_len = tdata->iv.len;
14198         unsigned int aad_len = tdata->aad.len;
14199         unsigned int aad_len_pad = 0;
14200
14201         /* Generate Crypto op data structure */
14202         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
14203                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
14204         TEST_ASSERT_NOT_NULL(ut_params->op,
14205                 "Failed to allocate symmetric crypto operation struct");
14206
14207         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
14208
14209         sym_op->aead.digest.data = digest_mem;
14210
14211         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
14212                         "no room to append digest");
14213
14214         sym_op->aead.digest.phys_addr = digest_phys;
14215
14216         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
14217                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
14218                                 auth_tag_len);
14219                 debug_hexdump(stdout, "digest:",
14220                                 sym_op->aead.digest.data,
14221                                 auth_tag_len);
14222         }
14223
14224         /* Append aad data */
14225         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
14226                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14227                                 uint8_t *, IV_OFFSET);
14228
14229                 /* Copy IV 1 byte after the IV pointer, according to the API */
14230                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
14231
14232                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
14233
14234                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14235                                 ut_params->ibuf, aad_len);
14236                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14237                                 "no room to prepend aad");
14238                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14239                                 ut_params->ibuf);
14240
14241                 memset(sym_op->aead.aad.data, 0, aad_len);
14242                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
14243                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14244
14245                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14246                 debug_hexdump(stdout, "aad:",
14247                                 sym_op->aead.aad.data, aad_len);
14248         } else {
14249                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14250                                 uint8_t *, IV_OFFSET);
14251
14252                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
14253
14254                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
14255
14256                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14257                                 ut_params->ibuf, aad_len_pad);
14258                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14259                                 "no room to prepend aad");
14260                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14261                                 ut_params->ibuf);
14262
14263                 memset(sym_op->aead.aad.data, 0, aad_len);
14264                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14265
14266                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14267                 debug_hexdump(stdout, "aad:",
14268                                 sym_op->aead.aad.data, aad_len);
14269         }
14270
14271         sym_op->aead.data.length = tdata->plaintext.len;
14272         sym_op->aead.data.offset = aad_len_pad;
14273
14274         return 0;
14275 }
14276
14277 #define SGL_MAX_NO      16
14278
14279 static int
14280 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
14281                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
14282 {
14283         struct crypto_testsuite_params *ts_params = &testsuite_params;
14284         struct crypto_unittest_params *ut_params = &unittest_params;
14285         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
14286         int retval;
14287         int to_trn = 0;
14288         int to_trn_tbl[SGL_MAX_NO];
14289         int segs = 1;
14290         unsigned int trn_data = 0;
14291         uint8_t *plaintext, *ciphertext, *auth_tag;
14292         struct rte_cryptodev_info dev_info;
14293
14294         /* Verify the capabilities */
14295         struct rte_cryptodev_sym_capability_idx cap_idx;
14296         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
14297         cap_idx.algo.aead = tdata->algo;
14298         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14299                         &cap_idx) == NULL)
14300                 return TEST_SKIPPED;
14301
14302         /* OOP not supported with CPU crypto */
14303         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14304                 return TEST_SKIPPED;
14305
14306         /* Detailed check for the particular SGL support flag */
14307         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14308         if (!oop) {
14309                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14310                 if (sgl_in && (!(dev_info.feature_flags &
14311                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
14312                         return TEST_SKIPPED;
14313
14314                 uint64_t feat_flags = dev_info.feature_flags;
14315
14316                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14317                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14318                         printf("Device doesn't support RAW data-path APIs.\n");
14319                         return TEST_SKIPPED;
14320                 }
14321         } else {
14322                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14323                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
14324                                 tdata->plaintext.len;
14325                 /* Raw data path API does not support OOP */
14326                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14327                         return TEST_SKIPPED;
14328                 if (sgl_in && !sgl_out) {
14329                         if (!(dev_info.feature_flags &
14330                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
14331                                 return TEST_SKIPPED;
14332                 } else if (!sgl_in && sgl_out) {
14333                         if (!(dev_info.feature_flags &
14334                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
14335                                 return TEST_SKIPPED;
14336                 } else if (sgl_in && sgl_out) {
14337                         if (!(dev_info.feature_flags &
14338                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
14339                                 return TEST_SKIPPED;
14340                 }
14341         }
14342
14343         if (fragsz > tdata->plaintext.len)
14344                 fragsz = tdata->plaintext.len;
14345
14346         uint16_t plaintext_len = fragsz;
14347         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
14348
14349         if (fragsz_oop > tdata->plaintext.len)
14350                 frag_size_oop = tdata->plaintext.len;
14351
14352         int ecx = 0;
14353         void *digest_mem = NULL;
14354
14355         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
14356
14357         if (tdata->plaintext.len % fragsz != 0) {
14358                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
14359                         return 1;
14360         }       else {
14361                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
14362                         return 1;
14363         }
14364
14365         /*
14366          * For out-op-place we need to alloc another mbuf
14367          */
14368         if (oop) {
14369                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14370                 rte_pktmbuf_append(ut_params->obuf,
14371                                 frag_size_oop + prepend_len);
14372                 buf_oop = ut_params->obuf;
14373         }
14374
14375         /* Create AEAD session */
14376         retval = create_aead_session(ts_params->valid_devs[0],
14377                         tdata->algo,
14378                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
14379                         tdata->key.data, tdata->key.len,
14380                         tdata->aad.len, tdata->auth_tag.len,
14381                         tdata->iv.len);
14382         if (retval < 0)
14383                 return retval;
14384
14385         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14386
14387         /* clear mbuf payload */
14388         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14389                         rte_pktmbuf_tailroom(ut_params->ibuf));
14390
14391         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14392                         plaintext_len);
14393
14394         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
14395
14396         trn_data += plaintext_len;
14397
14398         buf = ut_params->ibuf;
14399
14400         /*
14401          * Loop until no more fragments
14402          */
14403
14404         while (trn_data < tdata->plaintext.len) {
14405                 ++segs;
14406                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
14407                                 (tdata->plaintext.len - trn_data) : fragsz;
14408
14409                 to_trn_tbl[ecx++] = to_trn;
14410
14411                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14412                 buf = buf->next;
14413
14414                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
14415                                 rte_pktmbuf_tailroom(buf));
14416
14417                 /* OOP */
14418                 if (oop && !fragsz_oop) {
14419                         buf_last_oop = buf_oop->next =
14420                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14421                         buf_oop = buf_oop->next;
14422                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14423                                         0, rte_pktmbuf_tailroom(buf_oop));
14424                         rte_pktmbuf_append(buf_oop, to_trn);
14425                 }
14426
14427                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
14428                                 to_trn);
14429
14430                 memcpy(plaintext, tdata->plaintext.data + trn_data,
14431                                 to_trn);
14432                 trn_data += to_trn;
14433                 if (trn_data  == tdata->plaintext.len) {
14434                         if (oop) {
14435                                 if (!fragsz_oop)
14436                                         digest_mem = rte_pktmbuf_append(buf_oop,
14437                                                 tdata->auth_tag.len);
14438                         } else
14439                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
14440                                         tdata->auth_tag.len);
14441                 }
14442         }
14443
14444         uint64_t digest_phys = 0;
14445
14446         ut_params->ibuf->nb_segs = segs;
14447
14448         segs = 1;
14449         if (fragsz_oop && oop) {
14450                 to_trn = 0;
14451                 ecx = 0;
14452
14453                 if (frag_size_oop == tdata->plaintext.len) {
14454                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
14455                                 tdata->auth_tag.len);
14456
14457                         digest_phys = rte_pktmbuf_iova_offset(
14458                                         ut_params->obuf,
14459                                         tdata->plaintext.len + prepend_len);
14460                 }
14461
14462                 trn_data = frag_size_oop;
14463                 while (trn_data < tdata->plaintext.len) {
14464                         ++segs;
14465                         to_trn =
14466                                 (tdata->plaintext.len - trn_data <
14467                                                 frag_size_oop) ?
14468                                 (tdata->plaintext.len - trn_data) :
14469                                                 frag_size_oop;
14470
14471                         to_trn_tbl[ecx++] = to_trn;
14472
14473                         buf_last_oop = buf_oop->next =
14474                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14475                         buf_oop = buf_oop->next;
14476                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14477                                         0, rte_pktmbuf_tailroom(buf_oop));
14478                         rte_pktmbuf_append(buf_oop, to_trn);
14479
14480                         trn_data += to_trn;
14481
14482                         if (trn_data  == tdata->plaintext.len) {
14483                                 digest_mem = rte_pktmbuf_append(buf_oop,
14484                                         tdata->auth_tag.len);
14485                         }
14486                 }
14487
14488                 ut_params->obuf->nb_segs = segs;
14489         }
14490
14491         /*
14492          * Place digest at the end of the last buffer
14493          */
14494         if (!digest_phys)
14495                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14496         if (oop && buf_last_oop)
14497                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14498
14499         if (!digest_mem && !oop) {
14500                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14501                                 + tdata->auth_tag.len);
14502                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14503                                 tdata->plaintext.len);
14504         }
14505
14506         /* Create AEAD operation */
14507         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14508                         tdata, digest_mem, digest_phys);
14509
14510         if (retval < 0)
14511                 return retval;
14512
14513         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14514
14515         ut_params->op->sym->m_src = ut_params->ibuf;
14516         if (oop)
14517                 ut_params->op->sym->m_dst = ut_params->obuf;
14518
14519         /* Process crypto operation */
14520         if (oop == IN_PLACE &&
14521                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14522                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14523         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14524                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14525                                 ut_params->op, 0, 0, 0, 0);
14526         else
14527                 TEST_ASSERT_NOT_NULL(
14528                         process_crypto_request(ts_params->valid_devs[0],
14529                         ut_params->op), "failed to process sym crypto op");
14530
14531         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14532                         "crypto op processing failed");
14533
14534
14535         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14536                         uint8_t *, prepend_len);
14537         if (oop) {
14538                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14539                                 uint8_t *, prepend_len);
14540         }
14541
14542         if (fragsz_oop)
14543                 fragsz = fragsz_oop;
14544
14545         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14546                         ciphertext,
14547                         tdata->ciphertext.data,
14548                         fragsz,
14549                         "Ciphertext data not as expected");
14550
14551         buf = ut_params->op->sym->m_src->next;
14552         if (oop)
14553                 buf = ut_params->op->sym->m_dst->next;
14554
14555         unsigned int off = fragsz;
14556
14557         ecx = 0;
14558         while (buf) {
14559                 ciphertext = rte_pktmbuf_mtod(buf,
14560                                 uint8_t *);
14561
14562                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14563                                 ciphertext,
14564                                 tdata->ciphertext.data + off,
14565                                 to_trn_tbl[ecx],
14566                                 "Ciphertext data not as expected");
14567
14568                 off += to_trn_tbl[ecx++];
14569                 buf = buf->next;
14570         }
14571
14572         auth_tag = digest_mem;
14573         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14574                         auth_tag,
14575                         tdata->auth_tag.data,
14576                         tdata->auth_tag.len,
14577                         "Generated auth tag not as expected");
14578
14579         return 0;
14580 }
14581
14582 static int
14583 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14584 {
14585         return test_authenticated_encryption_SGL(
14586                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14587 }
14588
14589 static int
14590 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14591 {
14592         return test_authenticated_encryption_SGL(
14593                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14594 }
14595
14596 static int
14597 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14598 {
14599         return test_authenticated_encryption_SGL(
14600                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14601                         gcm_test_case_8.plaintext.len);
14602 }
14603
14604 static int
14605 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14606 {
14607         /* This test is not for OPENSSL PMD */
14608         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14609                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14610                 return TEST_SKIPPED;
14611
14612         return test_authenticated_encryption_SGL(
14613                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14614 }
14615
14616 static int
14617 test_authentication_verify_fail_when_data_corrupted(
14618                 struct crypto_testsuite_params *ts_params,
14619                 struct crypto_unittest_params *ut_params,
14620                 const struct test_crypto_vector *reference)
14621 {
14622         return test_authentication_verify_fail_when_data_corruption(
14623                         ts_params, ut_params, reference, 1);
14624 }
14625
14626 static int
14627 test_authentication_verify_fail_when_tag_corrupted(
14628                 struct crypto_testsuite_params *ts_params,
14629                 struct crypto_unittest_params *ut_params,
14630                 const struct test_crypto_vector *reference)
14631 {
14632         return test_authentication_verify_fail_when_data_corruption(
14633                         ts_params, ut_params, reference, 0);
14634 }
14635
14636 static int
14637 test_authentication_verify_GMAC_fail_when_data_corrupted(
14638                 struct crypto_testsuite_params *ts_params,
14639                 struct crypto_unittest_params *ut_params,
14640                 const struct test_crypto_vector *reference)
14641 {
14642         return test_authentication_verify_GMAC_fail_when_corruption(
14643                         ts_params, ut_params, reference, 1);
14644 }
14645
14646 static int
14647 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14648                 struct crypto_testsuite_params *ts_params,
14649                 struct crypto_unittest_params *ut_params,
14650                 const struct test_crypto_vector *reference)
14651 {
14652         return test_authentication_verify_GMAC_fail_when_corruption(
14653                         ts_params, ut_params, reference, 0);
14654 }
14655
14656 static int
14657 test_authenticated_decryption_fail_when_data_corrupted(
14658                 struct crypto_testsuite_params *ts_params,
14659                 struct crypto_unittest_params *ut_params,
14660                 const struct test_crypto_vector *reference)
14661 {
14662         return test_authenticated_decryption_fail_when_corruption(
14663                         ts_params, ut_params, reference, 1);
14664 }
14665
14666 static int
14667 test_authenticated_decryption_fail_when_tag_corrupted(
14668                 struct crypto_testsuite_params *ts_params,
14669                 struct crypto_unittest_params *ut_params,
14670                 const struct test_crypto_vector *reference)
14671 {
14672         return test_authenticated_decryption_fail_when_corruption(
14673                         ts_params, ut_params, reference, 0);
14674 }
14675
14676 static int
14677 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14678 {
14679         return test_authentication_verify_fail_when_data_corrupted(
14680                         &testsuite_params, &unittest_params,
14681                         &hmac_sha1_test_crypto_vector);
14682 }
14683
14684 static int
14685 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14686 {
14687         return test_authentication_verify_fail_when_tag_corrupted(
14688                         &testsuite_params, &unittest_params,
14689                         &hmac_sha1_test_crypto_vector);
14690 }
14691
14692 static int
14693 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14694 {
14695         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14696                         &testsuite_params, &unittest_params,
14697                         &aes128_gmac_test_vector);
14698 }
14699
14700 static int
14701 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14702 {
14703         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14704                         &testsuite_params, &unittest_params,
14705                         &aes128_gmac_test_vector);
14706 }
14707
14708 static int
14709 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14710 {
14711         return test_authenticated_decryption_fail_when_data_corrupted(
14712                         &testsuite_params,
14713                         &unittest_params,
14714                         &aes128cbc_hmac_sha1_test_vector);
14715 }
14716
14717 static int
14718 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14719 {
14720         return test_authenticated_decryption_fail_when_tag_corrupted(
14721                         &testsuite_params,
14722                         &unittest_params,
14723                         &aes128cbc_hmac_sha1_test_vector);
14724 }
14725
14726 static int
14727 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14728 {
14729         return test_authenticated_encrypt_with_esn(
14730                         &testsuite_params,
14731                         &unittest_params,
14732                         &aes128cbc_hmac_sha1_aad_test_vector);
14733 }
14734
14735 static int
14736 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14737 {
14738         return test_authenticated_decrypt_with_esn(
14739                         &testsuite_params,
14740                         &unittest_params,
14741                         &aes128cbc_hmac_sha1_aad_test_vector);
14742 }
14743
14744 static int
14745 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14746 {
14747         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14748 }
14749
14750 static int
14751 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14752 {
14753         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14754 }
14755
14756 static int
14757 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14758 {
14759         return test_authenticated_encryption_SGL(
14760                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14761                 chacha20_poly1305_case_2.plaintext.len);
14762 }
14763
14764 #ifdef RTE_CRYPTO_SCHEDULER
14765
14766 /* global AESNI worker IDs for the scheduler test */
14767 uint8_t aesni_ids[2];
14768
14769 static int
14770 scheduler_testsuite_setup(void)
14771 {
14772         uint32_t i = 0;
14773         int32_t nb_devs, ret;
14774         char vdev_args[VDEV_ARGS_SIZE] = {""};
14775         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14776                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14777         uint16_t worker_core_count = 0;
14778         uint16_t socket_id = 0;
14779
14780         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14781                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14782
14783                 /* Identify the Worker Cores
14784                  * Use 2 worker cores for the device args
14785                  */
14786                 RTE_LCORE_FOREACH_WORKER(i) {
14787                         if (worker_core_count > 1)
14788                                 break;
14789                         snprintf(vdev_args, sizeof(vdev_args),
14790                                         "%s%d", temp_str, i);
14791                         strcpy(temp_str, vdev_args);
14792                         strlcat(temp_str, ";", sizeof(temp_str));
14793                         worker_core_count++;
14794                         socket_id = rte_lcore_to_socket_id(i);
14795                 }
14796                 if (worker_core_count != 2) {
14797                         RTE_LOG(ERR, USER1,
14798                                 "Cryptodev scheduler test require at least "
14799                                 "two worker cores to run. "
14800                                 "Please use the correct coremask.\n");
14801                         return TEST_FAILED;
14802                 }
14803                 strcpy(temp_str, vdev_args);
14804                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14805                                 temp_str, socket_id);
14806                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14807                 nb_devs = rte_cryptodev_device_count_by_driver(
14808                                 rte_cryptodev_driver_id_get(
14809                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14810                 if (nb_devs < 1) {
14811                         ret = rte_vdev_init(
14812                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14813                                         vdev_args);
14814                         TEST_ASSERT(ret == 0,
14815                                 "Failed to create instance %u of pmd : %s",
14816                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14817                 }
14818         }
14819         return testsuite_setup();
14820 }
14821
14822 static int
14823 test_scheduler_attach_worker_op(void)
14824 {
14825         struct crypto_testsuite_params *ts_params = &testsuite_params;
14826         uint8_t sched_id = ts_params->valid_devs[0];
14827         uint32_t i, nb_devs_attached = 0;
14828         int ret;
14829         char vdev_name[32];
14830         unsigned int count = rte_cryptodev_count();
14831
14832         /* create 2 AESNI_MB vdevs on top of existing devices */
14833         for (i = count; i < count + 2; i++) {
14834                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14835                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14836                                 i);
14837                 ret = rte_vdev_init(vdev_name, NULL);
14838
14839                 TEST_ASSERT(ret == 0,
14840                         "Failed to create instance %u of"
14841                         " pmd : %s",
14842                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14843
14844                 if (ret < 0) {
14845                         RTE_LOG(ERR, USER1,
14846                                 "Failed to create 2 AESNI MB PMDs.\n");
14847                         return TEST_SKIPPED;
14848                 }
14849         }
14850
14851         /* attach 2 AESNI_MB cdevs */
14852         for (i = count; i < count + 2; i++) {
14853                 struct rte_cryptodev_info info;
14854                 unsigned int session_size;
14855
14856                 rte_cryptodev_info_get(i, &info);
14857                 if (info.driver_id != rte_cryptodev_driver_id_get(
14858                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14859                         continue;
14860
14861                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14862                 /*
14863                  * Create the session mempool again, since now there are new devices
14864                  * to use the mempool.
14865                  */
14866                 if (ts_params->session_mpool) {
14867                         rte_mempool_free(ts_params->session_mpool);
14868                         ts_params->session_mpool = NULL;
14869                 }
14870                 if (ts_params->session_priv_mpool) {
14871                         rte_mempool_free(ts_params->session_priv_mpool);
14872                         ts_params->session_priv_mpool = NULL;
14873                 }
14874
14875                 if (info.sym.max_nb_sessions != 0 &&
14876                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14877                         RTE_LOG(ERR, USER1,
14878                                         "Device does not support "
14879                                         "at least %u sessions\n",
14880                                         MAX_NB_SESSIONS);
14881                         return TEST_FAILED;
14882                 }
14883                 /*
14884                  * Create mempool with maximum number of sessions,
14885                  * to include the session headers
14886                  */
14887                 if (ts_params->session_mpool == NULL) {
14888                         ts_params->session_mpool =
14889                                 rte_cryptodev_sym_session_pool_create(
14890                                                 "test_sess_mp",
14891                                                 MAX_NB_SESSIONS, 0, 0, 0,
14892                                                 SOCKET_ID_ANY);
14893                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14894                                         "session mempool allocation failed");
14895                 }
14896
14897                 /*
14898                  * Create mempool with maximum number of sessions,
14899                  * to include device specific session private data
14900                  */
14901                 if (ts_params->session_priv_mpool == NULL) {
14902                         ts_params->session_priv_mpool = rte_mempool_create(
14903                                         "test_sess_mp_priv",
14904                                         MAX_NB_SESSIONS,
14905                                         session_size,
14906                                         0, 0, NULL, NULL, NULL,
14907                                         NULL, SOCKET_ID_ANY,
14908                                         0);
14909
14910                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14911                                         "session mempool allocation failed");
14912                 }
14913
14914                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14915                 ts_params->qp_conf.mp_session_private =
14916                                 ts_params->session_priv_mpool;
14917
14918                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14919                                 (uint8_t)i);
14920
14921                 TEST_ASSERT(ret == 0,
14922                         "Failed to attach device %u of pmd : %s", i,
14923                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14924
14925                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14926
14927                 nb_devs_attached++;
14928         }
14929
14930         return 0;
14931 }
14932
14933 static int
14934 test_scheduler_detach_worker_op(void)
14935 {
14936         struct crypto_testsuite_params *ts_params = &testsuite_params;
14937         uint8_t sched_id = ts_params->valid_devs[0];
14938         uint32_t i;
14939         int ret;
14940
14941         for (i = 0; i < 2; i++) {
14942                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14943                                 aesni_ids[i]);
14944                 TEST_ASSERT(ret == 0,
14945                         "Failed to detach device %u", aesni_ids[i]);
14946         }
14947
14948         return 0;
14949 }
14950
14951 static int
14952 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14953 {
14954         struct crypto_testsuite_params *ts_params = &testsuite_params;
14955         uint8_t sched_id = ts_params->valid_devs[0];
14956         /* set mode */
14957         return rte_cryptodev_scheduler_mode_set(sched_id,
14958                 scheduler_mode);
14959 }
14960
14961 static int
14962 test_scheduler_mode_roundrobin_op(void)
14963 {
14964         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14965                         0, "Failed to set roundrobin mode");
14966         return 0;
14967
14968 }
14969
14970 static int
14971 test_scheduler_mode_multicore_op(void)
14972 {
14973         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14974                         0, "Failed to set multicore mode");
14975
14976         return 0;
14977 }
14978
14979 static int
14980 test_scheduler_mode_failover_op(void)
14981 {
14982         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14983                         0, "Failed to set failover mode");
14984
14985         return 0;
14986 }
14987
14988 static int
14989 test_scheduler_mode_pkt_size_distr_op(void)
14990 {
14991         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14992                         0, "Failed to set pktsize mode");
14993
14994         return 0;
14995 }
14996
14997 static int
14998 scheduler_multicore_testsuite_setup(void)
14999 {
15000         if (test_scheduler_attach_worker_op() < 0)
15001                 return TEST_SKIPPED;
15002         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
15003                 return TEST_SKIPPED;
15004         return 0;
15005 }
15006
15007 static int
15008 scheduler_roundrobin_testsuite_setup(void)
15009 {
15010         if (test_scheduler_attach_worker_op() < 0)
15011                 return TEST_SKIPPED;
15012         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
15013                 return TEST_SKIPPED;
15014         return 0;
15015 }
15016
15017 static int
15018 scheduler_failover_testsuite_setup(void)
15019 {
15020         if (test_scheduler_attach_worker_op() < 0)
15021                 return TEST_SKIPPED;
15022         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
15023                 return TEST_SKIPPED;
15024         return 0;
15025 }
15026
15027 static int
15028 scheduler_pkt_size_distr_testsuite_setup(void)
15029 {
15030         if (test_scheduler_attach_worker_op() < 0)
15031                 return TEST_SKIPPED;
15032         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
15033                 return TEST_SKIPPED;
15034         return 0;
15035 }
15036
15037 static void
15038 scheduler_mode_testsuite_teardown(void)
15039 {
15040         test_scheduler_detach_worker_op();
15041 }
15042
15043 #endif /* RTE_CRYPTO_SCHEDULER */
15044
15045 static struct unit_test_suite end_testsuite = {
15046         .suite_name = NULL,
15047         .setup = NULL,
15048         .teardown = NULL,
15049         .unit_test_suites = NULL
15050 };
15051
15052 #ifdef RTE_LIB_SECURITY
15053 static struct unit_test_suite ipsec_proto_testsuite  = {
15054         .suite_name = "IPsec Proto Unit Test Suite",
15055         .setup = ipsec_proto_testsuite_setup,
15056         .unit_test_cases = {
15057                 TEST_CASE_NAMED_WITH_DATA(
15058                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15059                         ut_setup_security, ut_teardown,
15060                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
15061                 TEST_CASE_NAMED_WITH_DATA(
15062                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15063                         ut_setup_security, ut_teardown,
15064                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
15065                 TEST_CASE_NAMED_WITH_DATA(
15066                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15067                         ut_setup_security, ut_teardown,
15068                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
15069                 TEST_CASE_NAMED_WITH_DATA(
15070                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15071                         ut_setup_security, ut_teardown,
15072                         test_ipsec_proto_known_vec,
15073                         &pkt_aes_128_cbc_hmac_sha256),
15074                 TEST_CASE_NAMED_WITH_DATA(
15075                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15076                         ut_setup_security, ut_teardown,
15077                         test_ipsec_proto_known_vec,
15078                         &pkt_aes_128_cbc_hmac_sha384),
15079                 TEST_CASE_NAMED_WITH_DATA(
15080                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15081                         ut_setup_security, ut_teardown,
15082                         test_ipsec_proto_known_vec,
15083                         &pkt_aes_128_cbc_hmac_sha512),
15084                 TEST_CASE_NAMED_WITH_DATA(
15085                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15086                         ut_setup_security, ut_teardown,
15087                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
15088                 TEST_CASE_NAMED_WITH_DATA(
15089                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15090                         ut_setup_security, ut_teardown,
15091                         test_ipsec_proto_known_vec,
15092                         &pkt_aes_128_cbc_hmac_sha256_v6),
15093                 TEST_CASE_NAMED_WITH_DATA(
15094                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15095                         ut_setup_security, ut_teardown,
15096                         test_ipsec_proto_known_vec,
15097                         &pkt_null_aes_xcbc),
15098                 TEST_CASE_NAMED_WITH_DATA(
15099                         "Outbound known vector (AH tunnel mode IPv4 HMAC-SHA256)",
15100                         ut_setup_security, ut_teardown,
15101                         test_ipsec_proto_known_vec,
15102                         &pkt_ah_tunnel_sha256),
15103                 TEST_CASE_NAMED_WITH_DATA(
15104                         "Outbound known vector (AH transport mode IPv4 HMAC-SHA256)",
15105                         ut_setup_security, ut_teardown,
15106                         test_ipsec_proto_known_vec,
15107                         &pkt_ah_transport_sha256),
15108                 TEST_CASE_NAMED_WITH_DATA(
15109                         "Outbound known vector (AH transport mode IPv4 AES-GMAC 128)",
15110                         ut_setup_security, ut_teardown,
15111                         test_ipsec_proto_known_vec,
15112                         &pkt_ah_ipv4_aes_gmac_128),
15113                 TEST_CASE_NAMED_WITH_DATA(
15114                         "Outbound fragmented packet",
15115                         ut_setup_security, ut_teardown,
15116                         test_ipsec_proto_known_vec_fragmented,
15117                         &pkt_aes_128_gcm_frag),
15118                 TEST_CASE_NAMED_WITH_DATA(
15119                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15120                         ut_setup_security, ut_teardown,
15121                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
15122                 TEST_CASE_NAMED_WITH_DATA(
15123                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15124                         ut_setup_security, ut_teardown,
15125                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
15126                 TEST_CASE_NAMED_WITH_DATA(
15127                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15128                         ut_setup_security, ut_teardown,
15129                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
15130                 TEST_CASE_NAMED_WITH_DATA(
15131                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
15132                         ut_setup_security, ut_teardown,
15133                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
15134                 TEST_CASE_NAMED_WITH_DATA(
15135                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15136                         ut_setup_security, ut_teardown,
15137                         test_ipsec_proto_known_vec_inb,
15138                         &pkt_aes_128_cbc_hmac_sha256),
15139                 TEST_CASE_NAMED_WITH_DATA(
15140                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15141                         ut_setup_security, ut_teardown,
15142                         test_ipsec_proto_known_vec_inb,
15143                         &pkt_aes_128_cbc_hmac_sha384),
15144                 TEST_CASE_NAMED_WITH_DATA(
15145                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15146                         ut_setup_security, ut_teardown,
15147                         test_ipsec_proto_known_vec_inb,
15148                         &pkt_aes_128_cbc_hmac_sha512),
15149                 TEST_CASE_NAMED_WITH_DATA(
15150                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15151                         ut_setup_security, ut_teardown,
15152                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
15153                 TEST_CASE_NAMED_WITH_DATA(
15154                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15155                         ut_setup_security, ut_teardown,
15156                         test_ipsec_proto_known_vec_inb,
15157                         &pkt_aes_128_cbc_hmac_sha256_v6),
15158                 TEST_CASE_NAMED_WITH_DATA(
15159                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15160                         ut_setup_security, ut_teardown,
15161                         test_ipsec_proto_known_vec_inb,
15162                         &pkt_null_aes_xcbc),
15163                 TEST_CASE_NAMED_WITH_DATA(
15164                         "Inbound known vector (AH tunnel mode IPv4 HMAC-SHA256)",
15165                         ut_setup_security, ut_teardown,
15166                         test_ipsec_proto_known_vec_inb,
15167                         &pkt_ah_tunnel_sha256),
15168                 TEST_CASE_NAMED_WITH_DATA(
15169                         "Inbound known vector (AH transport mode IPv4 HMAC-SHA256)",
15170                         ut_setup_security, ut_teardown,
15171                         test_ipsec_proto_known_vec_inb,
15172                         &pkt_ah_transport_sha256),
15173                 TEST_CASE_NAMED_WITH_DATA(
15174                         "Inbound known vector (AH transport mode IPv4 AES-GMAC 128)",
15175                         ut_setup_security, ut_teardown,
15176                         test_ipsec_proto_known_vec_inb,
15177                         &pkt_ah_ipv4_aes_gmac_128),
15178                 TEST_CASE_NAMED_ST(
15179                         "Combined test alg list",
15180                         ut_setup_security, ut_teardown,
15181                         test_ipsec_proto_display_list),
15182                 TEST_CASE_NAMED_ST(
15183                         "Combined test alg list (AH)",
15184                         ut_setup_security, ut_teardown,
15185                         test_ipsec_proto_ah_tunnel_ipv4),
15186                 TEST_CASE_NAMED_ST(
15187                         "IV generation",
15188                         ut_setup_security, ut_teardown,
15189                         test_ipsec_proto_iv_gen),
15190                 TEST_CASE_NAMED_ST(
15191                         "UDP encapsulation",
15192                         ut_setup_security, ut_teardown,
15193                         test_ipsec_proto_udp_encap),
15194                 TEST_CASE_NAMED_ST(
15195                         "UDP encapsulation ports verification test",
15196                         ut_setup_security, ut_teardown,
15197                         test_ipsec_proto_udp_ports_verify),
15198                 TEST_CASE_NAMED_ST(
15199                         "SA expiry packets soft",
15200                         ut_setup_security, ut_teardown,
15201                         test_ipsec_proto_sa_exp_pkts_soft),
15202                 TEST_CASE_NAMED_ST(
15203                         "SA expiry packets hard",
15204                         ut_setup_security, ut_teardown,
15205                         test_ipsec_proto_sa_exp_pkts_hard),
15206                 TEST_CASE_NAMED_ST(
15207                         "Negative test: ICV corruption",
15208                         ut_setup_security, ut_teardown,
15209                         test_ipsec_proto_err_icv_corrupt),
15210                 TEST_CASE_NAMED_ST(
15211                         "Tunnel dst addr verification",
15212                         ut_setup_security, ut_teardown,
15213                         test_ipsec_proto_tunnel_dst_addr_verify),
15214                 TEST_CASE_NAMED_ST(
15215                         "Tunnel src and dst addr verification",
15216                         ut_setup_security, ut_teardown,
15217                         test_ipsec_proto_tunnel_src_dst_addr_verify),
15218                 TEST_CASE_NAMED_ST(
15219                         "Inner IP checksum",
15220                         ut_setup_security, ut_teardown,
15221                         test_ipsec_proto_inner_ip_csum),
15222                 TEST_CASE_NAMED_ST(
15223                         "Inner L4 checksum",
15224                         ut_setup_security, ut_teardown,
15225                         test_ipsec_proto_inner_l4_csum),
15226                 TEST_CASE_NAMED_ST(
15227                         "Tunnel IPv4 in IPv4",
15228                         ut_setup_security, ut_teardown,
15229                         test_ipsec_proto_tunnel_v4_in_v4),
15230                 TEST_CASE_NAMED_ST(
15231                         "Tunnel IPv6 in IPv6",
15232                         ut_setup_security, ut_teardown,
15233                         test_ipsec_proto_tunnel_v6_in_v6),
15234                 TEST_CASE_NAMED_ST(
15235                         "Tunnel IPv4 in IPv6",
15236                         ut_setup_security, ut_teardown,
15237                         test_ipsec_proto_tunnel_v4_in_v6),
15238                 TEST_CASE_NAMED_ST(
15239                         "Tunnel IPv6 in IPv4",
15240                         ut_setup_security, ut_teardown,
15241                         test_ipsec_proto_tunnel_v6_in_v4),
15242                 TEST_CASE_NAMED_ST(
15243                         "Transport IPv4",
15244                         ut_setup_security, ut_teardown,
15245                         test_ipsec_proto_transport_v4),
15246                 TEST_CASE_NAMED_ST(
15247                         "AH transport IPv4",
15248                         ut_setup_security, ut_teardown,
15249                         test_ipsec_proto_ah_transport_ipv4),
15250                 TEST_CASE_NAMED_ST(
15251                         "Transport l4 checksum",
15252                         ut_setup_security, ut_teardown,
15253                         test_ipsec_proto_transport_l4_csum),
15254                 TEST_CASE_NAMED_ST(
15255                         "Statistics: success",
15256                         ut_setup_security, ut_teardown,
15257                         test_ipsec_proto_stats),
15258                 TEST_CASE_NAMED_ST(
15259                         "Fragmented packet",
15260                         ut_setup_security, ut_teardown,
15261                         test_ipsec_proto_pkt_fragment),
15262                 TEST_CASE_NAMED_ST(
15263                         "Tunnel header copy DF (inner 0)",
15264                         ut_setup_security, ut_teardown,
15265                         test_ipsec_proto_copy_df_inner_0),
15266                 TEST_CASE_NAMED_ST(
15267                         "Tunnel header copy DF (inner 1)",
15268                         ut_setup_security, ut_teardown,
15269                         test_ipsec_proto_copy_df_inner_1),
15270                 TEST_CASE_NAMED_ST(
15271                         "Tunnel header set DF 0 (inner 1)",
15272                         ut_setup_security, ut_teardown,
15273                         test_ipsec_proto_set_df_0_inner_1),
15274                 TEST_CASE_NAMED_ST(
15275                         "Tunnel header set DF 1 (inner 0)",
15276                         ut_setup_security, ut_teardown,
15277                         test_ipsec_proto_set_df_1_inner_0),
15278                 TEST_CASE_NAMED_ST(
15279                         "Tunnel header IPv4 copy DSCP (inner 0)",
15280                         ut_setup_security, ut_teardown,
15281                         test_ipsec_proto_ipv4_copy_dscp_inner_0),
15282                 TEST_CASE_NAMED_ST(
15283                         "Tunnel header IPv4 copy DSCP (inner 1)",
15284                         ut_setup_security, ut_teardown,
15285                         test_ipsec_proto_ipv4_copy_dscp_inner_1),
15286                 TEST_CASE_NAMED_ST(
15287                         "Tunnel header IPv4 set DSCP 0 (inner 1)",
15288                         ut_setup_security, ut_teardown,
15289                         test_ipsec_proto_ipv4_set_dscp_0_inner_1),
15290                 TEST_CASE_NAMED_ST(
15291                         "Tunnel header IPv4 set DSCP 1 (inner 0)",
15292                         ut_setup_security, ut_teardown,
15293                         test_ipsec_proto_ipv4_set_dscp_1_inner_0),
15294                 TEST_CASE_NAMED_ST(
15295                         "Tunnel header IPv6 copy DSCP (inner 0)",
15296                         ut_setup_security, ut_teardown,
15297                         test_ipsec_proto_ipv6_copy_dscp_inner_0),
15298                 TEST_CASE_NAMED_ST(
15299                         "Tunnel header IPv6 copy DSCP (inner 1)",
15300                         ut_setup_security, ut_teardown,
15301                         test_ipsec_proto_ipv6_copy_dscp_inner_1),
15302                 TEST_CASE_NAMED_ST(
15303                         "Tunnel header IPv6 set DSCP 0 (inner 1)",
15304                         ut_setup_security, ut_teardown,
15305                         test_ipsec_proto_ipv6_set_dscp_0_inner_1),
15306                 TEST_CASE_NAMED_ST(
15307                         "Tunnel header IPv6 set DSCP 1 (inner 0)",
15308                         ut_setup_security, ut_teardown,
15309                         test_ipsec_proto_ipv6_set_dscp_1_inner_0),
15310                 TEST_CASE_NAMED_WITH_DATA(
15311                         "Antireplay with window size 1024",
15312                         ut_setup_security, ut_teardown,
15313                         test_ipsec_proto_pkt_antireplay1024, &pkt_aes_128_gcm),
15314                 TEST_CASE_NAMED_WITH_DATA(
15315                         "Antireplay with window size 2048",
15316                         ut_setup_security, ut_teardown,
15317                         test_ipsec_proto_pkt_antireplay2048, &pkt_aes_128_gcm),
15318                 TEST_CASE_NAMED_WITH_DATA(
15319                         "Antireplay with window size 4096",
15320                         ut_setup_security, ut_teardown,
15321                         test_ipsec_proto_pkt_antireplay4096, &pkt_aes_128_gcm),
15322                 TEST_CASE_NAMED_WITH_DATA(
15323                         "ESN and Antireplay with window size 1024",
15324                         ut_setup_security, ut_teardown,
15325                         test_ipsec_proto_pkt_esn_antireplay1024,
15326                         &pkt_aes_128_gcm),
15327                 TEST_CASE_NAMED_WITH_DATA(
15328                         "ESN and Antireplay with window size 2048",
15329                         ut_setup_security, ut_teardown,
15330                         test_ipsec_proto_pkt_esn_antireplay2048,
15331                         &pkt_aes_128_gcm),
15332                 TEST_CASE_NAMED_WITH_DATA(
15333                         "ESN and Antireplay with window size 4096",
15334                         ut_setup_security, ut_teardown,
15335                         test_ipsec_proto_pkt_esn_antireplay4096,
15336                         &pkt_aes_128_gcm),
15337                 TEST_CASE_NAMED_ST(
15338                         "Tunnel header IPv4 decrement inner TTL",
15339                         ut_setup_security, ut_teardown,
15340                         test_ipsec_proto_ipv4_ttl_decrement),
15341                 TEST_CASE_NAMED_ST(
15342                         "Tunnel header IPv6 decrement inner hop limit",
15343                         ut_setup_security, ut_teardown,
15344                         test_ipsec_proto_ipv6_hop_limit_decrement),
15345                 TEST_CASES_END() /**< NULL terminate unit test array */
15346         }
15347 };
15348
15349 static struct unit_test_suite pdcp_proto_testsuite  = {
15350         .suite_name = "PDCP Proto Unit Test Suite",
15351         .setup = pdcp_proto_testsuite_setup,
15352         .unit_test_cases = {
15353                 TEST_CASE_ST(ut_setup_security, ut_teardown,
15354                         test_PDCP_PROTO_all),
15355                 TEST_CASES_END() /**< NULL terminate unit test array */
15356         }
15357 };
15358
15359 #define ADD_UPLINK_TESTCASE(data)                                               \
15360         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
15361         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
15362
15363 #define ADD_DOWNLINK_TESTCASE(data)                                             \
15364         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
15365         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
15366
15367 static struct unit_test_suite docsis_proto_testsuite  = {
15368         .suite_name = "DOCSIS Proto Unit Test Suite",
15369         .setup = docsis_proto_testsuite_setup,
15370         .unit_test_cases = {
15371                 /* Uplink */
15372                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
15373                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
15374                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
15375                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
15376                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
15377                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
15378                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
15379                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
15380                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
15381                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
15382                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
15383                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
15384                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
15385                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
15386                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
15387                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
15388                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
15389                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
15390                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
15391                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
15392                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
15393                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
15394                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
15395                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
15396                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
15397                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
15398                 /* Downlink */
15399                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
15400                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
15401                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
15402                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
15403                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
15404                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
15405                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
15406                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
15407                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
15408                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
15409                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
15410                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
15411                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
15412                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
15413                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
15414                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
15415                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
15416                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
15417                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
15418                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
15419                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
15420                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
15421                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
15422                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
15423                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
15424                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
15425                 TEST_CASES_END() /**< NULL terminate unit test array */
15426         }
15427 };
15428 #endif
15429
15430 static struct unit_test_suite cryptodev_gen_testsuite  = {
15431         .suite_name = "Crypto General Unit Test Suite",
15432         .setup = crypto_gen_testsuite_setup,
15433         .unit_test_cases = {
15434                 TEST_CASE_ST(ut_setup, ut_teardown,
15435                                 test_device_configure_invalid_dev_id),
15436                 TEST_CASE_ST(ut_setup, ut_teardown,
15437                                 test_queue_pair_descriptor_setup),
15438                 TEST_CASE_ST(ut_setup, ut_teardown,
15439                                 test_device_configure_invalid_queue_pair_ids),
15440                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
15441                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
15442                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
15443                 TEST_CASES_END() /**< NULL terminate unit test array */
15444         }
15445 };
15446
15447 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
15448         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
15449         .setup = negative_hmac_sha1_testsuite_setup,
15450         .unit_test_cases = {
15451                 /** Negative tests */
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
15454                 TEST_CASE_ST(ut_setup, ut_teardown,
15455                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
15456                 TEST_CASE_ST(ut_setup, ut_teardown,
15457                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
15458                 TEST_CASE_ST(ut_setup, ut_teardown,
15459                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
15460
15461                 TEST_CASES_END() /**< NULL terminate unit test array */
15462         }
15463 };
15464
15465 static struct unit_test_suite cryptodev_multi_session_testsuite = {
15466         .suite_name = "Multi Session Unit Test Suite",
15467         .setup = multi_session_testsuite_setup,
15468         .unit_test_cases = {
15469                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
15470                 TEST_CASE_ST(ut_setup, ut_teardown,
15471                                 test_multi_session_random_usage),
15472
15473                 TEST_CASES_END() /**< NULL terminate unit test array */
15474         }
15475 };
15476
15477 static struct unit_test_suite cryptodev_null_testsuite  = {
15478         .suite_name = "NULL Test Suite",
15479         .setup = null_testsuite_setup,
15480         .unit_test_cases = {
15481                 TEST_CASE_ST(ut_setup, ut_teardown,
15482                         test_null_invalid_operation),
15483                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
15484                 TEST_CASES_END()
15485         }
15486 };
15487
15488 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
15489         .suite_name = "AES CCM Authenticated Test Suite",
15490         .setup = aes_ccm_auth_testsuite_setup,
15491         .unit_test_cases = {
15492                 /** AES CCM Authenticated Encryption 128 bits key*/
15493                 TEST_CASE_ST(ut_setup, ut_teardown,
15494                         test_AES_CCM_authenticated_encryption_test_case_128_1),
15495                 TEST_CASE_ST(ut_setup, ut_teardown,
15496                         test_AES_CCM_authenticated_encryption_test_case_128_2),
15497                 TEST_CASE_ST(ut_setup, ut_teardown,
15498                         test_AES_CCM_authenticated_encryption_test_case_128_3),
15499
15500                 /** AES CCM Authenticated Decryption 128 bits key*/
15501                 TEST_CASE_ST(ut_setup, ut_teardown,
15502                         test_AES_CCM_authenticated_decryption_test_case_128_1),
15503                 TEST_CASE_ST(ut_setup, ut_teardown,
15504                         test_AES_CCM_authenticated_decryption_test_case_128_2),
15505                 TEST_CASE_ST(ut_setup, ut_teardown,
15506                         test_AES_CCM_authenticated_decryption_test_case_128_3),
15507
15508                 /** AES CCM Authenticated Encryption 192 bits key */
15509                 TEST_CASE_ST(ut_setup, ut_teardown,
15510                         test_AES_CCM_authenticated_encryption_test_case_192_1),
15511                 TEST_CASE_ST(ut_setup, ut_teardown,
15512                         test_AES_CCM_authenticated_encryption_test_case_192_2),
15513                 TEST_CASE_ST(ut_setup, ut_teardown,
15514                         test_AES_CCM_authenticated_encryption_test_case_192_3),
15515
15516                 /** AES CCM Authenticated Decryption 192 bits key*/
15517                 TEST_CASE_ST(ut_setup, ut_teardown,
15518                         test_AES_CCM_authenticated_decryption_test_case_192_1),
15519                 TEST_CASE_ST(ut_setup, ut_teardown,
15520                         test_AES_CCM_authenticated_decryption_test_case_192_2),
15521                 TEST_CASE_ST(ut_setup, ut_teardown,
15522                         test_AES_CCM_authenticated_decryption_test_case_192_3),
15523
15524                 /** AES CCM Authenticated Encryption 256 bits key */
15525                 TEST_CASE_ST(ut_setup, ut_teardown,
15526                         test_AES_CCM_authenticated_encryption_test_case_256_1),
15527                 TEST_CASE_ST(ut_setup, ut_teardown,
15528                         test_AES_CCM_authenticated_encryption_test_case_256_2),
15529                 TEST_CASE_ST(ut_setup, ut_teardown,
15530                         test_AES_CCM_authenticated_encryption_test_case_256_3),
15531
15532                 /** AES CCM Authenticated Decryption 256 bits key*/
15533                 TEST_CASE_ST(ut_setup, ut_teardown,
15534                         test_AES_CCM_authenticated_decryption_test_case_256_1),
15535                 TEST_CASE_ST(ut_setup, ut_teardown,
15536                         test_AES_CCM_authenticated_decryption_test_case_256_2),
15537                 TEST_CASE_ST(ut_setup, ut_teardown,
15538                         test_AES_CCM_authenticated_decryption_test_case_256_3),
15539                 TEST_CASES_END()
15540         }
15541 };
15542
15543 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
15544         .suite_name = "AES GCM Authenticated Test Suite",
15545         .setup = aes_gcm_auth_testsuite_setup,
15546         .unit_test_cases = {
15547                 /** AES GCM Authenticated Encryption */
15548                 TEST_CASE_ST(ut_setup, ut_teardown,
15549                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
15550                 TEST_CASE_ST(ut_setup, ut_teardown,
15551                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
15552                 TEST_CASE_ST(ut_setup, ut_teardown,
15553                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
15554                 TEST_CASE_ST(ut_setup, ut_teardown,
15555                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
15556                 TEST_CASE_ST(ut_setup, ut_teardown,
15557                         test_AES_GCM_authenticated_encryption_test_case_1),
15558                 TEST_CASE_ST(ut_setup, ut_teardown,
15559                         test_AES_GCM_authenticated_encryption_test_case_2),
15560                 TEST_CASE_ST(ut_setup, ut_teardown,
15561                         test_AES_GCM_authenticated_encryption_test_case_3),
15562                 TEST_CASE_ST(ut_setup, ut_teardown,
15563                         test_AES_GCM_authenticated_encryption_test_case_4),
15564                 TEST_CASE_ST(ut_setup, ut_teardown,
15565                         test_AES_GCM_authenticated_encryption_test_case_5),
15566                 TEST_CASE_ST(ut_setup, ut_teardown,
15567                         test_AES_GCM_authenticated_encryption_test_case_6),
15568                 TEST_CASE_ST(ut_setup, ut_teardown,
15569                         test_AES_GCM_authenticated_encryption_test_case_7),
15570                 TEST_CASE_ST(ut_setup, ut_teardown,
15571                         test_AES_GCM_authenticated_encryption_test_case_8),
15572                 TEST_CASE_ST(ut_setup, ut_teardown,
15573                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
15574
15575                 /** AES GCM Authenticated Decryption */
15576                 TEST_CASE_ST(ut_setup, ut_teardown,
15577                         test_AES_GCM_authenticated_decryption_test_case_1),
15578                 TEST_CASE_ST(ut_setup, ut_teardown,
15579                         test_AES_GCM_authenticated_decryption_test_case_2),
15580                 TEST_CASE_ST(ut_setup, ut_teardown,
15581                         test_AES_GCM_authenticated_decryption_test_case_3),
15582                 TEST_CASE_ST(ut_setup, ut_teardown,
15583                         test_AES_GCM_authenticated_decryption_test_case_4),
15584                 TEST_CASE_ST(ut_setup, ut_teardown,
15585                         test_AES_GCM_authenticated_decryption_test_case_5),
15586                 TEST_CASE_ST(ut_setup, ut_teardown,
15587                         test_AES_GCM_authenticated_decryption_test_case_6),
15588                 TEST_CASE_ST(ut_setup, ut_teardown,
15589                         test_AES_GCM_authenticated_decryption_test_case_7),
15590                 TEST_CASE_ST(ut_setup, ut_teardown,
15591                         test_AES_GCM_authenticated_decryption_test_case_8),
15592                 TEST_CASE_ST(ut_setup, ut_teardown,
15593                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
15594
15595                 /** AES GCM Authenticated Encryption 192 bits key */
15596                 TEST_CASE_ST(ut_setup, ut_teardown,
15597                         test_AES_GCM_auth_encryption_test_case_192_1),
15598                 TEST_CASE_ST(ut_setup, ut_teardown,
15599                         test_AES_GCM_auth_encryption_test_case_192_2),
15600                 TEST_CASE_ST(ut_setup, ut_teardown,
15601                         test_AES_GCM_auth_encryption_test_case_192_3),
15602                 TEST_CASE_ST(ut_setup, ut_teardown,
15603                         test_AES_GCM_auth_encryption_test_case_192_4),
15604                 TEST_CASE_ST(ut_setup, ut_teardown,
15605                         test_AES_GCM_auth_encryption_test_case_192_5),
15606                 TEST_CASE_ST(ut_setup, ut_teardown,
15607                         test_AES_GCM_auth_encryption_test_case_192_6),
15608                 TEST_CASE_ST(ut_setup, ut_teardown,
15609                         test_AES_GCM_auth_encryption_test_case_192_7),
15610
15611                 /** AES GCM Authenticated Decryption 192 bits key */
15612                 TEST_CASE_ST(ut_setup, ut_teardown,
15613                         test_AES_GCM_auth_decryption_test_case_192_1),
15614                 TEST_CASE_ST(ut_setup, ut_teardown,
15615                         test_AES_GCM_auth_decryption_test_case_192_2),
15616                 TEST_CASE_ST(ut_setup, ut_teardown,
15617                         test_AES_GCM_auth_decryption_test_case_192_3),
15618                 TEST_CASE_ST(ut_setup, ut_teardown,
15619                         test_AES_GCM_auth_decryption_test_case_192_4),
15620                 TEST_CASE_ST(ut_setup, ut_teardown,
15621                         test_AES_GCM_auth_decryption_test_case_192_5),
15622                 TEST_CASE_ST(ut_setup, ut_teardown,
15623                         test_AES_GCM_auth_decryption_test_case_192_6),
15624                 TEST_CASE_ST(ut_setup, ut_teardown,
15625                         test_AES_GCM_auth_decryption_test_case_192_7),
15626
15627                 /** AES GCM Authenticated Encryption 256 bits key */
15628                 TEST_CASE_ST(ut_setup, ut_teardown,
15629                         test_AES_GCM_auth_encryption_test_case_256_1),
15630                 TEST_CASE_ST(ut_setup, ut_teardown,
15631                         test_AES_GCM_auth_encryption_test_case_256_2),
15632                 TEST_CASE_ST(ut_setup, ut_teardown,
15633                         test_AES_GCM_auth_encryption_test_case_256_3),
15634                 TEST_CASE_ST(ut_setup, ut_teardown,
15635                         test_AES_GCM_auth_encryption_test_case_256_4),
15636                 TEST_CASE_ST(ut_setup, ut_teardown,
15637                         test_AES_GCM_auth_encryption_test_case_256_5),
15638                 TEST_CASE_ST(ut_setup, ut_teardown,
15639                         test_AES_GCM_auth_encryption_test_case_256_6),
15640                 TEST_CASE_ST(ut_setup, ut_teardown,
15641                         test_AES_GCM_auth_encryption_test_case_256_7),
15642
15643                 /** AES GCM Authenticated Decryption 256 bits key */
15644                 TEST_CASE_ST(ut_setup, ut_teardown,
15645                         test_AES_GCM_auth_decryption_test_case_256_1),
15646                 TEST_CASE_ST(ut_setup, ut_teardown,
15647                         test_AES_GCM_auth_decryption_test_case_256_2),
15648                 TEST_CASE_ST(ut_setup, ut_teardown,
15649                         test_AES_GCM_auth_decryption_test_case_256_3),
15650                 TEST_CASE_ST(ut_setup, ut_teardown,
15651                         test_AES_GCM_auth_decryption_test_case_256_4),
15652                 TEST_CASE_ST(ut_setup, ut_teardown,
15653                         test_AES_GCM_auth_decryption_test_case_256_5),
15654                 TEST_CASE_ST(ut_setup, ut_teardown,
15655                         test_AES_GCM_auth_decryption_test_case_256_6),
15656                 TEST_CASE_ST(ut_setup, ut_teardown,
15657                         test_AES_GCM_auth_decryption_test_case_256_7),
15658
15659                 /** AES GCM Authenticated Encryption big aad size */
15660                 TEST_CASE_ST(ut_setup, ut_teardown,
15661                         test_AES_GCM_auth_encryption_test_case_aad_1),
15662                 TEST_CASE_ST(ut_setup, ut_teardown,
15663                         test_AES_GCM_auth_encryption_test_case_aad_2),
15664
15665                 /** AES GCM Authenticated Decryption big aad size */
15666                 TEST_CASE_ST(ut_setup, ut_teardown,
15667                         test_AES_GCM_auth_decryption_test_case_aad_1),
15668                 TEST_CASE_ST(ut_setup, ut_teardown,
15669                         test_AES_GCM_auth_decryption_test_case_aad_2),
15670
15671                 /** Out of place tests */
15672                 TEST_CASE_ST(ut_setup, ut_teardown,
15673                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15674                 TEST_CASE_ST(ut_setup, ut_teardown,
15675                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15676
15677                 /** Session-less tests */
15678                 TEST_CASE_ST(ut_setup, ut_teardown,
15679                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15680                 TEST_CASE_ST(ut_setup, ut_teardown,
15681                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15682
15683                 TEST_CASES_END()
15684         }
15685 };
15686
15687 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15688         .suite_name = "AES GMAC Authentication Test Suite",
15689         .setup = aes_gmac_auth_testsuite_setup,
15690         .unit_test_cases = {
15691                 TEST_CASE_ST(ut_setup, ut_teardown,
15692                         test_AES_GMAC_authentication_test_case_1),
15693                 TEST_CASE_ST(ut_setup, ut_teardown,
15694                         test_AES_GMAC_authentication_verify_test_case_1),
15695                 TEST_CASE_ST(ut_setup, ut_teardown,
15696                         test_AES_GMAC_authentication_test_case_2),
15697                 TEST_CASE_ST(ut_setup, ut_teardown,
15698                         test_AES_GMAC_authentication_verify_test_case_2),
15699                 TEST_CASE_ST(ut_setup, ut_teardown,
15700                         test_AES_GMAC_authentication_test_case_3),
15701                 TEST_CASE_ST(ut_setup, ut_teardown,
15702                         test_AES_GMAC_authentication_verify_test_case_3),
15703                 TEST_CASE_ST(ut_setup, ut_teardown,
15704                         test_AES_GMAC_authentication_test_case_4),
15705                 TEST_CASE_ST(ut_setup, ut_teardown,
15706                         test_AES_GMAC_authentication_verify_test_case_4),
15707                 TEST_CASE_ST(ut_setup, ut_teardown,
15708                         test_AES_GMAC_authentication_SGL_40B),
15709                 TEST_CASE_ST(ut_setup, ut_teardown,
15710                         test_AES_GMAC_authentication_SGL_80B),
15711                 TEST_CASE_ST(ut_setup, ut_teardown,
15712                         test_AES_GMAC_authentication_SGL_2048B),
15713                 TEST_CASE_ST(ut_setup, ut_teardown,
15714                         test_AES_GMAC_authentication_SGL_2047B),
15715
15716                 TEST_CASES_END()
15717         }
15718 };
15719
15720 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15721         .suite_name = "Chacha20-Poly1305 Test Suite",
15722         .setup = chacha20_poly1305_testsuite_setup,
15723         .unit_test_cases = {
15724                 TEST_CASE_ST(ut_setup, ut_teardown,
15725                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15726                 TEST_CASE_ST(ut_setup, ut_teardown,
15727                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15728                 TEST_CASE_ST(ut_setup, ut_teardown,
15729                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15730                 TEST_CASES_END()
15731         }
15732 };
15733
15734 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15735         .suite_name = "SNOW 3G Test Suite",
15736         .setup = snow3g_testsuite_setup,
15737         .unit_test_cases = {
15738                 /** SNOW 3G encrypt only (UEA2) */
15739                 TEST_CASE_ST(ut_setup, ut_teardown,
15740                         test_snow3g_encryption_test_case_1),
15741                 TEST_CASE_ST(ut_setup, ut_teardown,
15742                         test_snow3g_encryption_test_case_2),
15743                 TEST_CASE_ST(ut_setup, ut_teardown,
15744                         test_snow3g_encryption_test_case_3),
15745                 TEST_CASE_ST(ut_setup, ut_teardown,
15746                         test_snow3g_encryption_test_case_4),
15747                 TEST_CASE_ST(ut_setup, ut_teardown,
15748                         test_snow3g_encryption_test_case_5),
15749
15750                 TEST_CASE_ST(ut_setup, ut_teardown,
15751                         test_snow3g_encryption_test_case_1_oop),
15752                 TEST_CASE_ST(ut_setup, ut_teardown,
15753                         test_snow3g_encryption_test_case_1_oop_sgl),
15754                 TEST_CASE_ST(ut_setup, ut_teardown,
15755                         test_snow3g_encryption_test_case_1_offset_oop),
15756                 TEST_CASE_ST(ut_setup, ut_teardown,
15757                         test_snow3g_decryption_test_case_1_oop),
15758
15759                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15760                 TEST_CASE_ST(ut_setup, ut_teardown,
15761                         test_snow3g_auth_cipher_test_case_1),
15762                 TEST_CASE_ST(ut_setup, ut_teardown,
15763                         test_snow3g_auth_cipher_test_case_2),
15764                 TEST_CASE_ST(ut_setup, ut_teardown,
15765                         test_snow3g_auth_cipher_test_case_2_oop),
15766                 TEST_CASE_ST(ut_setup, ut_teardown,
15767                         test_snow3g_auth_cipher_part_digest_enc),
15768                 TEST_CASE_ST(ut_setup, ut_teardown,
15769                         test_snow3g_auth_cipher_part_digest_enc_oop),
15770                 TEST_CASE_ST(ut_setup, ut_teardown,
15771                         test_snow3g_auth_cipher_test_case_3_sgl),
15772                 TEST_CASE_ST(ut_setup, ut_teardown,
15773                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15774                 TEST_CASE_ST(ut_setup, ut_teardown,
15775                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15776                 TEST_CASE_ST(ut_setup, ut_teardown,
15777                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15778
15779                 /** SNOW 3G decrypt (UEA2), then verify auth */
15780                 TEST_CASE_ST(ut_setup, ut_teardown,
15781                         test_snow3g_auth_cipher_verify_test_case_1),
15782                 TEST_CASE_ST(ut_setup, ut_teardown,
15783                         test_snow3g_auth_cipher_verify_test_case_2),
15784                 TEST_CASE_ST(ut_setup, ut_teardown,
15785                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15786                 TEST_CASE_ST(ut_setup, ut_teardown,
15787                         test_snow3g_auth_cipher_verify_part_digest_enc),
15788                 TEST_CASE_ST(ut_setup, ut_teardown,
15789                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15790                 TEST_CASE_ST(ut_setup, ut_teardown,
15791                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15792                 TEST_CASE_ST(ut_setup, ut_teardown,
15793                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15794                 TEST_CASE_ST(ut_setup, ut_teardown,
15795                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15796                 TEST_CASE_ST(ut_setup, ut_teardown,
15797                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15798
15799                 /** SNOW 3G decrypt only (UEA2) */
15800                 TEST_CASE_ST(ut_setup, ut_teardown,
15801                         test_snow3g_decryption_test_case_1),
15802                 TEST_CASE_ST(ut_setup, ut_teardown,
15803                         test_snow3g_decryption_test_case_2),
15804                 TEST_CASE_ST(ut_setup, ut_teardown,
15805                         test_snow3g_decryption_test_case_3),
15806                 TEST_CASE_ST(ut_setup, ut_teardown,
15807                         test_snow3g_decryption_test_case_4),
15808                 TEST_CASE_ST(ut_setup, ut_teardown,
15809                         test_snow3g_decryption_test_case_5),
15810                 TEST_CASE_ST(ut_setup, ut_teardown,
15811                         test_snow3g_decryption_with_digest_test_case_1),
15812                 TEST_CASE_ST(ut_setup, ut_teardown,
15813                         test_snow3g_hash_generate_test_case_1),
15814                 TEST_CASE_ST(ut_setup, ut_teardown,
15815                         test_snow3g_hash_generate_test_case_2),
15816                 TEST_CASE_ST(ut_setup, ut_teardown,
15817                         test_snow3g_hash_generate_test_case_3),
15818
15819                 /* Tests with buffers which length is not byte-aligned */
15820                 TEST_CASE_ST(ut_setup, ut_teardown,
15821                         test_snow3g_hash_generate_test_case_4),
15822                 TEST_CASE_ST(ut_setup, ut_teardown,
15823                         test_snow3g_hash_generate_test_case_5),
15824                 TEST_CASE_ST(ut_setup, ut_teardown,
15825                         test_snow3g_hash_generate_test_case_6),
15826                 TEST_CASE_ST(ut_setup, ut_teardown,
15827                         test_snow3g_hash_verify_test_case_1),
15828                 TEST_CASE_ST(ut_setup, ut_teardown,
15829                         test_snow3g_hash_verify_test_case_2),
15830                 TEST_CASE_ST(ut_setup, ut_teardown,
15831                         test_snow3g_hash_verify_test_case_3),
15832
15833                 /* Tests with buffers which length is not byte-aligned */
15834                 TEST_CASE_ST(ut_setup, ut_teardown,
15835                         test_snow3g_hash_verify_test_case_4),
15836                 TEST_CASE_ST(ut_setup, ut_teardown,
15837                         test_snow3g_hash_verify_test_case_5),
15838                 TEST_CASE_ST(ut_setup, ut_teardown,
15839                         test_snow3g_hash_verify_test_case_6),
15840                 TEST_CASE_ST(ut_setup, ut_teardown,
15841                         test_snow3g_cipher_auth_test_case_1),
15842                 TEST_CASE_ST(ut_setup, ut_teardown,
15843                         test_snow3g_auth_cipher_with_digest_test_case_1),
15844                 TEST_CASES_END()
15845         }
15846 };
15847
15848 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15849         .suite_name = "ZUC Test Suite",
15850         .setup = zuc_testsuite_setup,
15851         .unit_test_cases = {
15852                 /** ZUC encrypt only (EEA3) */
15853                 TEST_CASE_ST(ut_setup, ut_teardown,
15854                         test_zuc_encryption_test_case_1),
15855                 TEST_CASE_ST(ut_setup, ut_teardown,
15856                         test_zuc_encryption_test_case_2),
15857                 TEST_CASE_ST(ut_setup, ut_teardown,
15858                         test_zuc_encryption_test_case_3),
15859                 TEST_CASE_ST(ut_setup, ut_teardown,
15860                         test_zuc_encryption_test_case_4),
15861                 TEST_CASE_ST(ut_setup, ut_teardown,
15862                         test_zuc_encryption_test_case_5),
15863                 TEST_CASE_ST(ut_setup, ut_teardown,
15864                         test_zuc_encryption_test_case_6_sgl),
15865
15866                 /** ZUC authenticate (EIA3) */
15867                 TEST_CASE_ST(ut_setup, ut_teardown,
15868                         test_zuc_hash_generate_test_case_1),
15869                 TEST_CASE_ST(ut_setup, ut_teardown,
15870                         test_zuc_hash_generate_test_case_2),
15871                 TEST_CASE_ST(ut_setup, ut_teardown,
15872                         test_zuc_hash_generate_test_case_3),
15873                 TEST_CASE_ST(ut_setup, ut_teardown,
15874                         test_zuc_hash_generate_test_case_4),
15875                 TEST_CASE_ST(ut_setup, ut_teardown,
15876                         test_zuc_hash_generate_test_case_5),
15877                 TEST_CASE_ST(ut_setup, ut_teardown,
15878                         test_zuc_hash_generate_test_case_6),
15879                 TEST_CASE_ST(ut_setup, ut_teardown,
15880                         test_zuc_hash_generate_test_case_7),
15881                 TEST_CASE_ST(ut_setup, ut_teardown,
15882                         test_zuc_hash_generate_test_case_8),
15883                 TEST_CASE_ST(ut_setup, ut_teardown,
15884                         test_zuc_hash_generate_test_case_9),
15885                 TEST_CASE_ST(ut_setup, ut_teardown,
15886                         test_zuc_hash_generate_test_case_10),
15887                 TEST_CASE_ST(ut_setup, ut_teardown,
15888                         test_zuc_hash_generate_test_case_11),
15889
15890
15891                 /** ZUC alg-chain (EEA3/EIA3) */
15892                 TEST_CASE_ST(ut_setup, ut_teardown,
15893                         test_zuc_cipher_auth_test_case_1),
15894                 TEST_CASE_ST(ut_setup, ut_teardown,
15895                         test_zuc_cipher_auth_test_case_2),
15896
15897                 /** ZUC generate auth, then encrypt (EEA3) */
15898                 TEST_CASE_ST(ut_setup, ut_teardown,
15899                         test_zuc_auth_cipher_test_case_1),
15900                 TEST_CASE_ST(ut_setup, ut_teardown,
15901                         test_zuc_auth_cipher_test_case_1_oop),
15902                 TEST_CASE_ST(ut_setup, ut_teardown,
15903                         test_zuc_auth_cipher_test_case_1_sgl),
15904                 TEST_CASE_ST(ut_setup, ut_teardown,
15905                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15906
15907                 /** ZUC decrypt (EEA3), then verify auth */
15908                 TEST_CASE_ST(ut_setup, ut_teardown,
15909                         test_zuc_auth_cipher_verify_test_case_1),
15910                 TEST_CASE_ST(ut_setup, ut_teardown,
15911                         test_zuc_auth_cipher_verify_test_case_1_oop),
15912                 TEST_CASE_ST(ut_setup, ut_teardown,
15913                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15914                 TEST_CASE_ST(ut_setup, ut_teardown,
15915                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15916
15917                 /** ZUC-256 encrypt only **/
15918                 TEST_CASE_ST(ut_setup, ut_teardown,
15919                         test_zuc256_encryption_test_case_1),
15920                 TEST_CASE_ST(ut_setup, ut_teardown,
15921                         test_zuc256_encryption_test_case_2),
15922
15923                 /** ZUC-256 authentication only **/
15924                 TEST_CASE_ST(ut_setup, ut_teardown,
15925                         test_zuc256_authentication_test_case_1),
15926                 TEST_CASE_ST(ut_setup, ut_teardown,
15927                         test_zuc256_authentication_test_case_2),
15928
15929                 TEST_CASES_END()
15930         }
15931 };
15932
15933 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15934         .suite_name = "HMAC_MD5 Authentication Test Suite",
15935         .setup = hmac_md5_auth_testsuite_setup,
15936         .unit_test_cases = {
15937                 TEST_CASE_ST(ut_setup, ut_teardown,
15938                         test_MD5_HMAC_generate_case_1),
15939                 TEST_CASE_ST(ut_setup, ut_teardown,
15940                         test_MD5_HMAC_verify_case_1),
15941                 TEST_CASE_ST(ut_setup, ut_teardown,
15942                         test_MD5_HMAC_generate_case_2),
15943                 TEST_CASE_ST(ut_setup, ut_teardown,
15944                         test_MD5_HMAC_verify_case_2),
15945                 TEST_CASES_END()
15946         }
15947 };
15948
15949 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15950         .suite_name = "Kasumi Test Suite",
15951         .setup = kasumi_testsuite_setup,
15952         .unit_test_cases = {
15953                 /** KASUMI hash only (UIA1) */
15954                 TEST_CASE_ST(ut_setup, ut_teardown,
15955                         test_kasumi_hash_generate_test_case_1),
15956                 TEST_CASE_ST(ut_setup, ut_teardown,
15957                         test_kasumi_hash_generate_test_case_2),
15958                 TEST_CASE_ST(ut_setup, ut_teardown,
15959                         test_kasumi_hash_generate_test_case_3),
15960                 TEST_CASE_ST(ut_setup, ut_teardown,
15961                         test_kasumi_hash_generate_test_case_4),
15962                 TEST_CASE_ST(ut_setup, ut_teardown,
15963                         test_kasumi_hash_generate_test_case_5),
15964                 TEST_CASE_ST(ut_setup, ut_teardown,
15965                         test_kasumi_hash_generate_test_case_6),
15966
15967                 TEST_CASE_ST(ut_setup, ut_teardown,
15968                         test_kasumi_hash_verify_test_case_1),
15969                 TEST_CASE_ST(ut_setup, ut_teardown,
15970                         test_kasumi_hash_verify_test_case_2),
15971                 TEST_CASE_ST(ut_setup, ut_teardown,
15972                         test_kasumi_hash_verify_test_case_3),
15973                 TEST_CASE_ST(ut_setup, ut_teardown,
15974                         test_kasumi_hash_verify_test_case_4),
15975                 TEST_CASE_ST(ut_setup, ut_teardown,
15976                         test_kasumi_hash_verify_test_case_5),
15977
15978                 /** KASUMI encrypt only (UEA1) */
15979                 TEST_CASE_ST(ut_setup, ut_teardown,
15980                         test_kasumi_encryption_test_case_1),
15981                 TEST_CASE_ST(ut_setup, ut_teardown,
15982                         test_kasumi_encryption_test_case_1_sgl),
15983                 TEST_CASE_ST(ut_setup, ut_teardown,
15984                         test_kasumi_encryption_test_case_1_oop),
15985                 TEST_CASE_ST(ut_setup, ut_teardown,
15986                         test_kasumi_encryption_test_case_1_oop_sgl),
15987                 TEST_CASE_ST(ut_setup, ut_teardown,
15988                         test_kasumi_encryption_test_case_2),
15989                 TEST_CASE_ST(ut_setup, ut_teardown,
15990                         test_kasumi_encryption_test_case_3),
15991                 TEST_CASE_ST(ut_setup, ut_teardown,
15992                         test_kasumi_encryption_test_case_4),
15993                 TEST_CASE_ST(ut_setup, ut_teardown,
15994                         test_kasumi_encryption_test_case_5),
15995
15996                 /** KASUMI decrypt only (UEA1) */
15997                 TEST_CASE_ST(ut_setup, ut_teardown,
15998                         test_kasumi_decryption_test_case_1),
15999                 TEST_CASE_ST(ut_setup, ut_teardown,
16000                         test_kasumi_decryption_test_case_2),
16001                 TEST_CASE_ST(ut_setup, ut_teardown,
16002                         test_kasumi_decryption_test_case_3),
16003                 TEST_CASE_ST(ut_setup, ut_teardown,
16004                         test_kasumi_decryption_test_case_4),
16005                 TEST_CASE_ST(ut_setup, ut_teardown,
16006                         test_kasumi_decryption_test_case_5),
16007                 TEST_CASE_ST(ut_setup, ut_teardown,
16008                         test_kasumi_decryption_test_case_1_oop),
16009                 TEST_CASE_ST(ut_setup, ut_teardown,
16010                         test_kasumi_cipher_auth_test_case_1),
16011
16012                 /** KASUMI generate auth, then encrypt (F8) */
16013                 TEST_CASE_ST(ut_setup, ut_teardown,
16014                         test_kasumi_auth_cipher_test_case_1),
16015                 TEST_CASE_ST(ut_setup, ut_teardown,
16016                         test_kasumi_auth_cipher_test_case_2),
16017                 TEST_CASE_ST(ut_setup, ut_teardown,
16018                         test_kasumi_auth_cipher_test_case_2_oop),
16019                 TEST_CASE_ST(ut_setup, ut_teardown,
16020                         test_kasumi_auth_cipher_test_case_2_sgl),
16021                 TEST_CASE_ST(ut_setup, ut_teardown,
16022                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
16023
16024                 /** KASUMI decrypt (F8), then verify auth */
16025                 TEST_CASE_ST(ut_setup, ut_teardown,
16026                         test_kasumi_auth_cipher_verify_test_case_1),
16027                 TEST_CASE_ST(ut_setup, ut_teardown,
16028                         test_kasumi_auth_cipher_verify_test_case_2),
16029                 TEST_CASE_ST(ut_setup, ut_teardown,
16030                         test_kasumi_auth_cipher_verify_test_case_2_oop),
16031                 TEST_CASE_ST(ut_setup, ut_teardown,
16032                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
16033                 TEST_CASE_ST(ut_setup, ut_teardown,
16034                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
16035
16036                 TEST_CASES_END()
16037         }
16038 };
16039
16040 static struct unit_test_suite cryptodev_esn_testsuite  = {
16041         .suite_name = "ESN Test Suite",
16042         .setup = esn_testsuite_setup,
16043         .unit_test_cases = {
16044                 TEST_CASE_ST(ut_setup, ut_teardown,
16045                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
16046                 TEST_CASE_ST(ut_setup, ut_teardown,
16047                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
16048                 TEST_CASES_END()
16049         }
16050 };
16051
16052 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
16053         .suite_name = "Negative AES GCM Test Suite",
16054         .setup = negative_aes_gcm_testsuite_setup,
16055         .unit_test_cases = {
16056                 TEST_CASE_ST(ut_setup, ut_teardown,
16057                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
16058                 TEST_CASE_ST(ut_setup, ut_teardown,
16059                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
16060                 TEST_CASE_ST(ut_setup, ut_teardown,
16061                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
16062                 TEST_CASE_ST(ut_setup, ut_teardown,
16063                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
16064                 TEST_CASE_ST(ut_setup, ut_teardown,
16065                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
16066                 TEST_CASE_ST(ut_setup, ut_teardown,
16067                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
16068                 TEST_CASE_ST(ut_setup, ut_teardown,
16069                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
16070                 TEST_CASE_ST(ut_setup, ut_teardown,
16071                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
16072                 TEST_CASE_ST(ut_setup, ut_teardown,
16073                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
16074                 TEST_CASE_ST(ut_setup, ut_teardown,
16075                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
16076                 TEST_CASE_ST(ut_setup, ut_teardown,
16077                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
16078                 TEST_CASE_ST(ut_setup, ut_teardown,
16079                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
16080
16081                 TEST_CASES_END()
16082         }
16083 };
16084
16085 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
16086         .suite_name = "Negative AES GMAC Test Suite",
16087         .setup = negative_aes_gmac_testsuite_setup,
16088         .unit_test_cases = {
16089                 TEST_CASE_ST(ut_setup, ut_teardown,
16090                         authentication_verify_AES128_GMAC_fail_data_corrupt),
16091                 TEST_CASE_ST(ut_setup, ut_teardown,
16092                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
16093
16094                 TEST_CASES_END()
16095         }
16096 };
16097
16098 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
16099         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
16100         .setup = mixed_cipher_hash_testsuite_setup,
16101         .unit_test_cases = {
16102                 /** AUTH AES CMAC + CIPHER AES CTR */
16103                 TEST_CASE_ST(ut_setup, ut_teardown,
16104                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
16105                 TEST_CASE_ST(ut_setup, ut_teardown,
16106                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16107                 TEST_CASE_ST(ut_setup, ut_teardown,
16108                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16109                 TEST_CASE_ST(ut_setup, ut_teardown,
16110                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16111                 TEST_CASE_ST(ut_setup, ut_teardown,
16112                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
16113                 TEST_CASE_ST(ut_setup, ut_teardown,
16114                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16115                 TEST_CASE_ST(ut_setup, ut_teardown,
16116                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16117                 TEST_CASE_ST(ut_setup, ut_teardown,
16118                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16119
16120                 /** AUTH ZUC + CIPHER SNOW3G */
16121                 TEST_CASE_ST(ut_setup, ut_teardown,
16122                         test_auth_zuc_cipher_snow_test_case_1),
16123                 TEST_CASE_ST(ut_setup, ut_teardown,
16124                         test_verify_auth_zuc_cipher_snow_test_case_1),
16125                 /** AUTH AES CMAC + CIPHER SNOW3G */
16126                 TEST_CASE_ST(ut_setup, ut_teardown,
16127                         test_auth_aes_cmac_cipher_snow_test_case_1),
16128                 TEST_CASE_ST(ut_setup, ut_teardown,
16129                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
16130                 /** AUTH ZUC + CIPHER AES CTR */
16131                 TEST_CASE_ST(ut_setup, ut_teardown,
16132                         test_auth_zuc_cipher_aes_ctr_test_case_1),
16133                 TEST_CASE_ST(ut_setup, ut_teardown,
16134                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
16135                 /** AUTH SNOW3G + CIPHER AES CTR */
16136                 TEST_CASE_ST(ut_setup, ut_teardown,
16137                         test_auth_snow_cipher_aes_ctr_test_case_1),
16138                 TEST_CASE_ST(ut_setup, ut_teardown,
16139                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
16140                 /** AUTH SNOW3G + CIPHER ZUC */
16141                 TEST_CASE_ST(ut_setup, ut_teardown,
16142                         test_auth_snow_cipher_zuc_test_case_1),
16143                 TEST_CASE_ST(ut_setup, ut_teardown,
16144                         test_verify_auth_snow_cipher_zuc_test_case_1),
16145                 /** AUTH AES CMAC + CIPHER ZUC */
16146                 TEST_CASE_ST(ut_setup, ut_teardown,
16147                         test_auth_aes_cmac_cipher_zuc_test_case_1),
16148                 TEST_CASE_ST(ut_setup, ut_teardown,
16149                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
16150
16151                 /** AUTH NULL + CIPHER SNOW3G */
16152                 TEST_CASE_ST(ut_setup, ut_teardown,
16153                         test_auth_null_cipher_snow_test_case_1),
16154                 TEST_CASE_ST(ut_setup, ut_teardown,
16155                         test_verify_auth_null_cipher_snow_test_case_1),
16156                 /** AUTH NULL + CIPHER ZUC */
16157                 TEST_CASE_ST(ut_setup, ut_teardown,
16158                         test_auth_null_cipher_zuc_test_case_1),
16159                 TEST_CASE_ST(ut_setup, ut_teardown,
16160                         test_verify_auth_null_cipher_zuc_test_case_1),
16161                 /** AUTH SNOW3G + CIPHER NULL */
16162                 TEST_CASE_ST(ut_setup, ut_teardown,
16163                         test_auth_snow_cipher_null_test_case_1),
16164                 TEST_CASE_ST(ut_setup, ut_teardown,
16165                         test_verify_auth_snow_cipher_null_test_case_1),
16166                 /** AUTH ZUC + CIPHER NULL */
16167                 TEST_CASE_ST(ut_setup, ut_teardown,
16168                         test_auth_zuc_cipher_null_test_case_1),
16169                 TEST_CASE_ST(ut_setup, ut_teardown,
16170                         test_verify_auth_zuc_cipher_null_test_case_1),
16171                 /** AUTH NULL + CIPHER AES CTR */
16172                 TEST_CASE_ST(ut_setup, ut_teardown,
16173                         test_auth_null_cipher_aes_ctr_test_case_1),
16174                 TEST_CASE_ST(ut_setup, ut_teardown,
16175                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
16176                 /** AUTH AES CMAC + CIPHER NULL */
16177                 TEST_CASE_ST(ut_setup, ut_teardown,
16178                         test_auth_aes_cmac_cipher_null_test_case_1),
16179                 TEST_CASE_ST(ut_setup, ut_teardown,
16180                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
16181                 TEST_CASES_END()
16182         }
16183 };
16184
16185 static int
16186 run_cryptodev_testsuite(const char *pmd_name)
16187 {
16188         uint8_t ret, j, i = 0, blk_start_idx = 0;
16189         const enum blockcipher_test_type blk_suites[] = {
16190                 BLKCIPHER_AES_CHAIN_TYPE,
16191                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16192                 BLKCIPHER_AES_DOCSIS_TYPE,
16193                 BLKCIPHER_3DES_CHAIN_TYPE,
16194                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
16195                 BLKCIPHER_DES_CIPHERONLY_TYPE,
16196                 BLKCIPHER_DES_DOCSIS_TYPE,
16197                 BLKCIPHER_AUTHONLY_TYPE};
16198         struct unit_test_suite *static_suites[] = {
16199                 &cryptodev_multi_session_testsuite,
16200                 &cryptodev_null_testsuite,
16201                 &cryptodev_aes_ccm_auth_testsuite,
16202                 &cryptodev_aes_gcm_auth_testsuite,
16203                 &cryptodev_aes_gmac_auth_testsuite,
16204                 &cryptodev_snow3g_testsuite,
16205                 &cryptodev_chacha20_poly1305_testsuite,
16206                 &cryptodev_zuc_testsuite,
16207                 &cryptodev_hmac_md5_auth_testsuite,
16208                 &cryptodev_kasumi_testsuite,
16209                 &cryptodev_esn_testsuite,
16210                 &cryptodev_negative_aes_gcm_testsuite,
16211                 &cryptodev_negative_aes_gmac_testsuite,
16212                 &cryptodev_mixed_cipher_hash_testsuite,
16213                 &cryptodev_negative_hmac_sha1_testsuite,
16214                 &cryptodev_gen_testsuite,
16215 #ifdef RTE_LIB_SECURITY
16216                 &ipsec_proto_testsuite,
16217                 &pdcp_proto_testsuite,
16218                 &docsis_proto_testsuite,
16219 #endif
16220                 &end_testsuite
16221         };
16222         static struct unit_test_suite ts = {
16223                 .suite_name = "Cryptodev Unit Test Suite",
16224                 .setup = testsuite_setup,
16225                 .teardown = testsuite_teardown,
16226                 .unit_test_cases = {TEST_CASES_END()}
16227         };
16228
16229         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
16230
16231         if (gbl_driver_id == -1) {
16232                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
16233                 return TEST_SKIPPED;
16234         }
16235
16236         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16237                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
16238
16239         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
16240         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16241         ret = unit_test_suite_runner(&ts);
16242
16243         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
16244         free(ts.unit_test_suites);
16245         return ret;
16246 }
16247
16248 static int
16249 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
16250 {
16251         struct rte_cryptodev_info dev_info;
16252         uint8_t i, nb_devs;
16253         int driver_id;
16254
16255         driver_id = rte_cryptodev_driver_id_get(pmd_name);
16256         if (driver_id == -1) {
16257                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
16258                 return TEST_SKIPPED;
16259         }
16260
16261         nb_devs = rte_cryptodev_count();
16262         if (nb_devs < 1) {
16263                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
16264                 return TEST_SKIPPED;
16265         }
16266
16267         for (i = 0; i < nb_devs; i++) {
16268                 rte_cryptodev_info_get(i, &dev_info);
16269                 if (dev_info.driver_id == driver_id) {
16270                         if (!(dev_info.feature_flags & flag)) {
16271                                 RTE_LOG(INFO, USER1, "%s not supported\n",
16272                                                 flag_name);
16273                                 return TEST_SKIPPED;
16274                         }
16275                         return 0; /* found */
16276                 }
16277         }
16278
16279         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
16280         return TEST_SKIPPED;
16281 }
16282
16283 static int
16284 test_cryptodev_qat(void)
16285 {
16286         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
16287 }
16288
16289 static int
16290 test_cryptodev_virtio(void)
16291 {
16292         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
16293 }
16294
16295 static int
16296 test_cryptodev_aesni_mb(void)
16297 {
16298         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16299 }
16300
16301 static int
16302 test_cryptodev_cpu_aesni_mb(void)
16303 {
16304         int32_t rc;
16305         enum rte_security_session_action_type at = gbl_action_type;
16306         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16307         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16308         gbl_action_type = at;
16309         return rc;
16310 }
16311
16312 static int
16313 test_cryptodev_chacha_poly_mb(void)
16314 {
16315         int32_t rc;
16316         enum rte_security_session_action_type at = gbl_action_type;
16317         rc = run_cryptodev_testsuite(
16318                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
16319         gbl_action_type = at;
16320         return rc;
16321 }
16322
16323 static int
16324 test_cryptodev_openssl(void)
16325 {
16326         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
16327 }
16328
16329 static int
16330 test_cryptodev_aesni_gcm(void)
16331 {
16332         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16333 }
16334
16335 static int
16336 test_cryptodev_cpu_aesni_gcm(void)
16337 {
16338         int32_t rc;
16339         enum rte_security_session_action_type at = gbl_action_type;
16340         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16341         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16342         gbl_action_type = at;
16343         return rc;
16344 }
16345
16346 static int
16347 test_cryptodev_mlx5(void)
16348 {
16349         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
16350 }
16351
16352 static int
16353 test_cryptodev_null(void)
16354 {
16355         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
16356 }
16357
16358 static int
16359 test_cryptodev_sw_snow3g(void)
16360 {
16361         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
16362 }
16363
16364 static int
16365 test_cryptodev_sw_kasumi(void)
16366 {
16367         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
16368 }
16369
16370 static int
16371 test_cryptodev_sw_zuc(void)
16372 {
16373         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
16374 }
16375
16376 static int
16377 test_cryptodev_armv8(void)
16378 {
16379         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
16380 }
16381
16382 static int
16383 test_cryptodev_mrvl(void)
16384 {
16385         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
16386 }
16387
16388 #ifdef RTE_CRYPTO_SCHEDULER
16389
16390 static int
16391 test_cryptodev_scheduler(void)
16392 {
16393         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
16394         const enum blockcipher_test_type blk_suites[] = {
16395                 BLKCIPHER_AES_CHAIN_TYPE,
16396                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16397                 BLKCIPHER_AUTHONLY_TYPE
16398         };
16399         static struct unit_test_suite scheduler_multicore = {
16400                 .suite_name = "Scheduler Multicore Unit Test Suite",
16401                 .setup = scheduler_multicore_testsuite_setup,
16402                 .teardown = scheduler_mode_testsuite_teardown,
16403                 .unit_test_cases = {TEST_CASES_END()}
16404         };
16405         static struct unit_test_suite scheduler_round_robin = {
16406                 .suite_name = "Scheduler Round Robin Unit Test Suite",
16407                 .setup = scheduler_roundrobin_testsuite_setup,
16408                 .teardown = scheduler_mode_testsuite_teardown,
16409                 .unit_test_cases = {TEST_CASES_END()}
16410         };
16411         static struct unit_test_suite scheduler_failover = {
16412                 .suite_name = "Scheduler Failover Unit Test Suite",
16413                 .setup = scheduler_failover_testsuite_setup,
16414                 .teardown = scheduler_mode_testsuite_teardown,
16415                 .unit_test_cases = {TEST_CASES_END()}
16416         };
16417         static struct unit_test_suite scheduler_pkt_size_distr = {
16418                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
16419                 .setup = scheduler_pkt_size_distr_testsuite_setup,
16420                 .teardown = scheduler_mode_testsuite_teardown,
16421                 .unit_test_cases = {TEST_CASES_END()}
16422         };
16423         struct unit_test_suite *sched_mode_suites[] = {
16424                 &scheduler_multicore,
16425                 &scheduler_round_robin,
16426                 &scheduler_failover,
16427                 &scheduler_pkt_size_distr
16428         };
16429         static struct unit_test_suite scheduler_config = {
16430                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
16431                 .unit_test_cases = {
16432                         TEST_CASE(test_scheduler_attach_worker_op),
16433                         TEST_CASE(test_scheduler_mode_multicore_op),
16434                         TEST_CASE(test_scheduler_mode_roundrobin_op),
16435                         TEST_CASE(test_scheduler_mode_failover_op),
16436                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
16437                         TEST_CASE(test_scheduler_detach_worker_op),
16438
16439                         TEST_CASES_END() /**< NULL terminate array */
16440                 }
16441         };
16442         struct unit_test_suite *static_suites[] = {
16443                 &scheduler_config,
16444                 &end_testsuite
16445         };
16446         static struct unit_test_suite ts = {
16447                 .suite_name = "Scheduler Unit Test Suite",
16448                 .setup = scheduler_testsuite_setup,
16449                 .teardown = testsuite_teardown,
16450                 .unit_test_cases = {TEST_CASES_END()}
16451         };
16452
16453         gbl_driver_id = rte_cryptodev_driver_id_get(
16454                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
16455
16456         if (gbl_driver_id == -1) {
16457                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
16458                 return TEST_SKIPPED;
16459         }
16460
16461         if (rte_cryptodev_driver_id_get(
16462                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
16463                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
16464                 return TEST_SKIPPED;
16465         }
16466
16467         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16468                 uint8_t blk_i = 0;
16469                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
16470                                 (struct unit_test_suite *) *
16471                                 (RTE_DIM(blk_suites) + 1));
16472                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
16473                                 blk_suites, RTE_DIM(blk_suites));
16474                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
16475         }
16476
16477         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16478                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
16479         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
16480                         RTE_DIM(sched_mode_suites));
16481         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16482         ret = unit_test_suite_runner(&ts);
16483
16484         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16485                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
16486                                 (*sched_mode_suites[sched_i]),
16487                                 RTE_DIM(blk_suites));
16488                 free(sched_mode_suites[sched_i]->unit_test_suites);
16489         }
16490         free(ts.unit_test_suites);
16491         return ret;
16492 }
16493
16494 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
16495
16496 #endif
16497
16498 static int
16499 test_cryptodev_dpaa2_sec(void)
16500 {
16501         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
16502 }
16503
16504 static int
16505 test_cryptodev_dpaa_sec(void)
16506 {
16507         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
16508 }
16509
16510 static int
16511 test_cryptodev_ccp(void)
16512 {
16513         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
16514 }
16515
16516 static int
16517 test_cryptodev_octeontx(void)
16518 {
16519         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
16520 }
16521
16522 static int
16523 test_cryptodev_caam_jr(void)
16524 {
16525         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
16526 }
16527
16528 static int
16529 test_cryptodev_nitrox(void)
16530 {
16531         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
16532 }
16533
16534 static int
16535 test_cryptodev_bcmfs(void)
16536 {
16537         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
16538 }
16539
16540 static int
16541 test_cryptodev_qat_raw_api(void)
16542 {
16543         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
16544         int ret;
16545
16546         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16547                         "RAW API");
16548         if (ret)
16549                 return ret;
16550
16551         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16552         ret = run_cryptodev_testsuite(pmd_name);
16553         global_api_test_type = CRYPTODEV_API_TEST;
16554
16555         return ret;
16556 }
16557
16558 static int
16559 test_cryptodev_cn9k(void)
16560 {
16561         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
16562 }
16563
16564 static int
16565 test_cryptodev_cn10k(void)
16566 {
16567         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
16568 }
16569
16570 static int
16571 test_cryptodev_dpaa2_sec_raw_api(void)
16572 {
16573         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16574         int ret;
16575
16576         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16577                         "RAW API");
16578         if (ret)
16579                 return ret;
16580
16581         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16582         ret = run_cryptodev_testsuite(pmd_name);
16583         global_api_test_type = CRYPTODEV_API_TEST;
16584
16585         return ret;
16586 }
16587
16588 static int
16589 test_cryptodev_dpaa_sec_raw_api(void)
16590 {
16591         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16592         int ret;
16593
16594         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16595                         "RAW API");
16596         if (ret)
16597                 return ret;
16598
16599         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16600         ret = run_cryptodev_testsuite(pmd_name);
16601         global_api_test_type = CRYPTODEV_API_TEST;
16602
16603         return ret;
16604 }
16605
16606 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
16607                 test_cryptodev_dpaa2_sec_raw_api);
16608 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
16609                 test_cryptodev_dpaa_sec_raw_api);
16610 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
16611                 test_cryptodev_qat_raw_api);
16612 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
16613 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
16614 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
16615         test_cryptodev_cpu_aesni_mb);
16616 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
16617         test_cryptodev_chacha_poly_mb);
16618 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16619 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16620 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16621         test_cryptodev_cpu_aesni_gcm);
16622 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16623 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16624 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16625 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16626 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16627 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16628 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16629 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16630 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16631 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16632 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16633 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16634 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16635 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16636 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16637 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16638 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
16639
16640 #endif /* !RTE_EXEC_ENV_WINDOWS */