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
 849         /*
 850          * Stop the device. Device would be started again by individual test
 851          * case setup routine.
 852          */
 853         rte_cryptodev_stop(ts_params->valid_devs[0]);
 854
 855         return ret;
 856 }
 857
 858 static int
 859 pdcp_proto_testsuite_setup(void)
 860 {
 861         struct crypto_testsuite_params *ts_params = &testsuite_params;
 862         uint8_t dev_id = ts_params->valid_devs[0];
 863         struct rte_cryptodev_info dev_info;
 864         const enum rte_crypto_cipher_algorithm ciphers[] = {
 865                 RTE_CRYPTO_CIPHER_NULL,
 866                 RTE_CRYPTO_CIPHER_AES_CTR,
 867                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 868                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 869         };
 870         const enum rte_crypto_auth_algorithm auths[] = {
 871                 RTE_CRYPTO_AUTH_NULL,
 872                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 873                 RTE_CRYPTO_AUTH_AES_CMAC,
 874                 RTE_CRYPTO_AUTH_ZUC_EIA3
 875         };
 876
 877         rte_cryptodev_info_get(dev_id, &dev_info);
 878
 879         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 880                         !(dev_info.feature_flags &
 881                         RTE_CRYPTODEV_FF_SECURITY)) {
 882                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 883                                 "testsuite not met\n");
 884                 return TEST_SKIPPED;
 885         }
 886
 887         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 888                         && check_auth_capabilities_supported(auths,
 889                         RTE_DIM(auths)) != 0) {
 890                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 891                                 "testsuite not met\n");
 892                 return TEST_SKIPPED;
 893         }
 894
 895         return 0;
 896 }
 897
 898 static int
 899 docsis_proto_testsuite_setup(void)
 900 {
 901         struct crypto_testsuite_params *ts_params = &testsuite_params;
 902         uint8_t dev_id = ts_params->valid_devs[0];
 903         struct rte_cryptodev_info dev_info;
 904         const enum rte_crypto_cipher_algorithm ciphers[] = {
 905                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 906         };
 907
 908         rte_cryptodev_info_get(dev_id, &dev_info);
 909
 910         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 911                         !(dev_info.feature_flags &
 912                         RTE_CRYPTODEV_FF_SECURITY)) {
 913                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 914                                 "Proto testsuite not met\n");
 915                 return TEST_SKIPPED;
 916         }
 917
 918         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 919                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 920                                 "testsuite not met\n");
 921                 return TEST_SKIPPED;
 922         }
 923
 924         return 0;
 925 }
 926 #endif
 927
 928 static int
 929 aes_ccm_auth_testsuite_setup(void)
 930 {
 931         struct crypto_testsuite_params *ts_params = &testsuite_params;
 932         uint8_t dev_id = ts_params->valid_devs[0];
 933         struct rte_cryptodev_info dev_info;
 934         const enum rte_crypto_aead_algorithm aeads[] = {
 935                 RTE_CRYPTO_AEAD_AES_CCM
 936         };
 937
 938         rte_cryptodev_info_get(dev_id, &dev_info);
 939
 940         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 941                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 942                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 943                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 944                                 "testsuite not met\n");
 945                 return TEST_SKIPPED;
 946         }
 947
 948         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 949                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 950                                 "testsuite not met\n");
 951                 return TEST_SKIPPED;
 952         }
 953
 954         return 0;
 955 }
 956
 957 static int
 958 aes_gcm_auth_testsuite_setup(void)
 959 {
 960         struct crypto_testsuite_params *ts_params = &testsuite_params;
 961         uint8_t dev_id = ts_params->valid_devs[0];
 962         struct rte_cryptodev_info dev_info;
 963         const enum rte_crypto_aead_algorithm aeads[] = {
 964                 RTE_CRYPTO_AEAD_AES_GCM
 965         };
 966
 967         rte_cryptodev_info_get(dev_id, &dev_info);
 968
 969         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 970                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 971                                 "testsuite not met\n");
 972                 return TEST_SKIPPED;
 973         }
 974
 975         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 976                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 977                                 "testsuite not met\n");
 978                 return TEST_SKIPPED;
 979         }
 980
 981         return 0;
 982 }
 983
 984 static int
 985 aes_gmac_auth_testsuite_setup(void)
 986 {
 987         struct crypto_testsuite_params *ts_params = &testsuite_params;
 988         uint8_t dev_id = ts_params->valid_devs[0];
 989         struct rte_cryptodev_info dev_info;
 990         const enum rte_crypto_auth_algorithm auths[] = {
 991                 RTE_CRYPTO_AUTH_AES_GMAC
 992         };
 993
 994         rte_cryptodev_info_get(dev_id, &dev_info);
 995
 996         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 997                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 998                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 999                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
1000                                 "testsuite not met\n");
1001                 return TEST_SKIPPED;
1002         }
1003
1004         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1005                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
1006                                 "testsuite not met\n");
1007                 return TEST_SKIPPED;
1008         }
1009
1010         return 0;
1011 }
1012
1013 static int
1014 chacha20_poly1305_testsuite_setup(void)
1015 {
1016         struct crypto_testsuite_params *ts_params = &testsuite_params;
1017         uint8_t dev_id = ts_params->valid_devs[0];
1018         struct rte_cryptodev_info dev_info;
1019         const enum rte_crypto_aead_algorithm aeads[] = {
1020                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1021         };
1022
1023         rte_cryptodev_info_get(dev_id, &dev_info);
1024
1025         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1026                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1027                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1028                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1029                                 "Chacha20-Poly1305 testsuite not met\n");
1030                 return TEST_SKIPPED;
1031         }
1032
1033         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1034                 RTE_LOG(INFO, USER1, "Capability requirements for "
1035                                 "Chacha20-Poly1305 testsuite not met\n");
1036                 return TEST_SKIPPED;
1037         }
1038
1039         return 0;
1040 }
1041
1042 static int
1043 snow3g_testsuite_setup(void)
1044 {
1045         struct crypto_testsuite_params *ts_params = &testsuite_params;
1046         uint8_t dev_id = ts_params->valid_devs[0];
1047         struct rte_cryptodev_info dev_info;
1048         const enum rte_crypto_cipher_algorithm ciphers[] = {
1049                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1050
1051         };
1052         const enum rte_crypto_auth_algorithm auths[] = {
1053                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1054         };
1055
1056         rte_cryptodev_info_get(dev_id, &dev_info);
1057
1058         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1059                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1060                                 "testsuite not met\n");
1061                 return TEST_SKIPPED;
1062         }
1063
1064         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1065                         && check_auth_capabilities_supported(auths,
1066                         RTE_DIM(auths)) != 0) {
1067                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1068                                 "testsuite not met\n");
1069                 return TEST_SKIPPED;
1070         }
1071
1072         return 0;
1073 }
1074
1075 static int
1076 zuc_testsuite_setup(void)
1077 {
1078         struct crypto_testsuite_params *ts_params = &testsuite_params;
1079         uint8_t dev_id = ts_params->valid_devs[0];
1080         struct rte_cryptodev_info dev_info;
1081         const enum rte_crypto_cipher_algorithm ciphers[] = {
1082                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1083         };
1084         const enum rte_crypto_auth_algorithm auths[] = {
1085                 RTE_CRYPTO_AUTH_ZUC_EIA3
1086         };
1087
1088         rte_cryptodev_info_get(dev_id, &dev_info);
1089
1090         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1091                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1092                                 "testsuite not met\n");
1093                 return TEST_SKIPPED;
1094         }
1095
1096         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1097                         && check_auth_capabilities_supported(auths,
1098                         RTE_DIM(auths)) != 0) {
1099                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1100                                 "testsuite not met\n");
1101                 return TEST_SKIPPED;
1102         }
1103
1104         return 0;
1105 }
1106
1107 static int
1108 hmac_md5_auth_testsuite_setup(void)
1109 {
1110         struct crypto_testsuite_params *ts_params = &testsuite_params;
1111         uint8_t dev_id = ts_params->valid_devs[0];
1112         struct rte_cryptodev_info dev_info;
1113         const enum rte_crypto_auth_algorithm auths[] = {
1114                 RTE_CRYPTO_AUTH_MD5_HMAC
1115         };
1116
1117         rte_cryptodev_info_get(dev_id, &dev_info);
1118
1119         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1120                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1121                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1122                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1123                                 "Auth testsuite not met\n");
1124                 return TEST_SKIPPED;
1125         }
1126
1127         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1128                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1129                                 "testsuite not met\n");
1130                 return TEST_SKIPPED;
1131         }
1132
1133         return 0;
1134 }
1135
1136 static int
1137 kasumi_testsuite_setup(void)
1138 {
1139         struct crypto_testsuite_params *ts_params = &testsuite_params;
1140         uint8_t dev_id = ts_params->valid_devs[0];
1141         struct rte_cryptodev_info dev_info;
1142         const enum rte_crypto_cipher_algorithm ciphers[] = {
1143                 RTE_CRYPTO_CIPHER_KASUMI_F8
1144         };
1145         const enum rte_crypto_auth_algorithm auths[] = {
1146                 RTE_CRYPTO_AUTH_KASUMI_F9
1147         };
1148
1149         rte_cryptodev_info_get(dev_id, &dev_info);
1150
1151         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1152                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1153                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1154                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1155                                 "testsuite not met\n");
1156                 return TEST_SKIPPED;
1157         }
1158
1159         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1160                         && check_auth_capabilities_supported(auths,
1161                         RTE_DIM(auths)) != 0) {
1162                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1163                                 "testsuite not met\n");
1164                 return TEST_SKIPPED;
1165         }
1166
1167         return 0;
1168 }
1169
1170 static int
1171 negative_aes_gcm_testsuite_setup(void)
1172 {
1173         struct crypto_testsuite_params *ts_params = &testsuite_params;
1174         uint8_t dev_id = ts_params->valid_devs[0];
1175         struct rte_cryptodev_info dev_info;
1176         const enum rte_crypto_aead_algorithm aeads[] = {
1177                 RTE_CRYPTO_AEAD_AES_GCM
1178         };
1179
1180         rte_cryptodev_info_get(dev_id, &dev_info);
1181
1182         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1183                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1184                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1185                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1186                                 "AES GCM testsuite not met\n");
1187                 return TEST_SKIPPED;
1188         }
1189
1190         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1191                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1192                                 "AES GCM testsuite not met\n");
1193                 return TEST_SKIPPED;
1194         }
1195
1196         return 0;
1197 }
1198
1199 static int
1200 negative_aes_gmac_testsuite_setup(void)
1201 {
1202         struct crypto_testsuite_params *ts_params = &testsuite_params;
1203         uint8_t dev_id = ts_params->valid_devs[0];
1204         struct rte_cryptodev_info dev_info;
1205         const enum rte_crypto_auth_algorithm auths[] = {
1206                 RTE_CRYPTO_AUTH_AES_GMAC
1207         };
1208
1209         rte_cryptodev_info_get(dev_id, &dev_info);
1210
1211         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1212                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1213                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1214                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1215                                 "AES GMAC testsuite not met\n");
1216                 return TEST_SKIPPED;
1217         }
1218
1219         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1220                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1221                                 "AES GMAC testsuite not met\n");
1222                 return TEST_SKIPPED;
1223         }
1224
1225         return 0;
1226 }
1227
1228 static int
1229 mixed_cipher_hash_testsuite_setup(void)
1230 {
1231         struct crypto_testsuite_params *ts_params = &testsuite_params;
1232         uint8_t dev_id = ts_params->valid_devs[0];
1233         struct rte_cryptodev_info dev_info;
1234         uint64_t feat_flags;
1235         const enum rte_crypto_cipher_algorithm ciphers[] = {
1236                 RTE_CRYPTO_CIPHER_NULL,
1237                 RTE_CRYPTO_CIPHER_AES_CTR,
1238                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1239                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1240         };
1241         const enum rte_crypto_auth_algorithm auths[] = {
1242                 RTE_CRYPTO_AUTH_NULL,
1243                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1244                 RTE_CRYPTO_AUTH_AES_CMAC,
1245                 RTE_CRYPTO_AUTH_ZUC_EIA3
1246         };
1247
1248         rte_cryptodev_info_get(dev_id, &dev_info);
1249         feat_flags = dev_info.feature_flags;
1250
1251         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1252                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1253                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1254                                 "Cipher Hash testsuite not met\n");
1255                 return TEST_SKIPPED;
1256         }
1257
1258         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1259                         && check_auth_capabilities_supported(auths,
1260                         RTE_DIM(auths)) != 0) {
1261                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1262                                 "Cipher Hash testsuite not met\n");
1263                 return TEST_SKIPPED;
1264         }
1265
1266         return 0;
1267 }
1268
1269 static int
1270 esn_testsuite_setup(void)
1271 {
1272         struct crypto_testsuite_params *ts_params = &testsuite_params;
1273         uint8_t dev_id = ts_params->valid_devs[0];
1274         struct rte_cryptodev_info dev_info;
1275         const enum rte_crypto_cipher_algorithm ciphers[] = {
1276                 RTE_CRYPTO_CIPHER_AES_CBC
1277         };
1278         const enum rte_crypto_auth_algorithm auths[] = {
1279                 RTE_CRYPTO_AUTH_SHA1_HMAC
1280         };
1281
1282         rte_cryptodev_info_get(dev_id, &dev_info);
1283
1284         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1285                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1286                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1287                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1288                                 "testsuite not met\n");
1289                 return TEST_SKIPPED;
1290         }
1291
1292         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1293                         && check_auth_capabilities_supported(auths,
1294                         RTE_DIM(auths)) != 0) {
1295                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1296                                 "testsuite not met\n");
1297                 return TEST_SKIPPED;
1298         }
1299
1300         return 0;
1301 }
1302
1303 static int
1304 multi_session_testsuite_setup(void)
1305 {
1306         struct crypto_testsuite_params *ts_params = &testsuite_params;
1307         uint8_t dev_id = ts_params->valid_devs[0];
1308         struct rte_cryptodev_info dev_info;
1309         const enum rte_crypto_cipher_algorithm ciphers[] = {
1310                 RTE_CRYPTO_CIPHER_AES_CBC
1311         };
1312         const enum rte_crypto_auth_algorithm auths[] = {
1313                 RTE_CRYPTO_AUTH_SHA512_HMAC
1314         };
1315
1316         rte_cryptodev_info_get(dev_id, &dev_info);
1317
1318         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1319                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1320                                 "Session testsuite not met\n");
1321                 return TEST_SKIPPED;
1322         }
1323
1324         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1325                         && check_auth_capabilities_supported(auths,
1326                         RTE_DIM(auths)) != 0) {
1327                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1328                                 "Session testsuite not met\n");
1329                 return TEST_SKIPPED;
1330         }
1331
1332         return 0;
1333 }
1334
1335 static int
1336 negative_hmac_sha1_testsuite_setup(void)
1337 {
1338         struct crypto_testsuite_params *ts_params = &testsuite_params;
1339         uint8_t dev_id = ts_params->valid_devs[0];
1340         struct rte_cryptodev_info dev_info;
1341         const enum rte_crypto_cipher_algorithm ciphers[] = {
1342                 RTE_CRYPTO_CIPHER_AES_CBC
1343         };
1344         const enum rte_crypto_auth_algorithm auths[] = {
1345                 RTE_CRYPTO_AUTH_SHA1_HMAC
1346         };
1347
1348         rte_cryptodev_info_get(dev_id, &dev_info);
1349
1350         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1351                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1352                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1353                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1354                                 "HMAC SHA1 testsuite not met\n");
1355                 return TEST_SKIPPED;
1356         }
1357
1358         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1359                         && check_auth_capabilities_supported(auths,
1360                         RTE_DIM(auths)) != 0) {
1361                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1362                                 "HMAC SHA1 testsuite not met\n");
1363                 return TEST_SKIPPED;
1364         }
1365
1366         return 0;
1367 }
1368
1369 static int
1370 dev_configure_and_start(uint64_t ff_disable)
1371 {
1372         struct crypto_testsuite_params *ts_params = &testsuite_params;
1373         struct crypto_unittest_params *ut_params = &unittest_params;
1374
1375         uint16_t qp_id;
1376
1377         /* Clear unit test parameters before running test */
1378         memset(ut_params, 0, sizeof(*ut_params));
1379
1380         /* Reconfigure device to default parameters */
1381         ts_params->conf.socket_id = SOCKET_ID_ANY;
1382         ts_params->conf.ff_disable = ff_disable;
1383         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1384         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1385         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1386
1387         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1388                         &ts_params->conf),
1389                         "Failed to configure cryptodev %u",
1390                         ts_params->valid_devs[0]);
1391
1392         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1393                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1394                         ts_params->valid_devs[0], qp_id,
1395                         &ts_params->qp_conf,
1396                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1397                         "Failed to setup queue pair %u on cryptodev %u",
1398                         qp_id, ts_params->valid_devs[0]);
1399         }
1400
1401
1402         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1403
1404         /* Start the device */
1405         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1406                         "Failed to start cryptodev %u",
1407                         ts_params->valid_devs[0]);
1408
1409         return TEST_SUCCESS;
1410 }
1411
1412 int
1413 ut_setup(void)
1414 {
1415         /* Configure and start the device with security feature disabled */
1416         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1417 }
1418
1419 static int
1420 ut_setup_security(void)
1421 {
1422         /* Configure and start the device with no features disabled */
1423         return dev_configure_and_start(0);
1424 }
1425
1426 void
1427 ut_teardown(void)
1428 {
1429         struct crypto_testsuite_params *ts_params = &testsuite_params;
1430         struct crypto_unittest_params *ut_params = &unittest_params;
1431
1432         /* free crypto session structure */
1433 #ifdef RTE_LIB_SECURITY
1434         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1435                 if (ut_params->sec_session) {
1436                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1437                                                 (ts_params->valid_devs[0]),
1438                                                 ut_params->sec_session);
1439                         ut_params->sec_session = NULL;
1440                 }
1441         } else
1442 #endif
1443         {
1444                 if (ut_params->sess) {
1445                         rte_cryptodev_sym_session_clear(
1446                                         ts_params->valid_devs[0],
1447                                         ut_params->sess);
1448                         rte_cryptodev_sym_session_free(ut_params->sess);
1449                         ut_params->sess = NULL;
1450                 }
1451         }
1452
1453         /* free crypto operation structure */
1454         if (ut_params->op)
1455                 rte_crypto_op_free(ut_params->op);
1456
1457         /*
1458          * free mbuf - both obuf and ibuf are usually the same,
1459          * so check if they point at the same address is necessary,
1460          * to avoid freeing the mbuf twice.
1461          */
1462         if (ut_params->obuf) {
1463                 rte_pktmbuf_free(ut_params->obuf);
1464                 if (ut_params->ibuf == ut_params->obuf)
1465                         ut_params->ibuf = 0;
1466                 ut_params->obuf = 0;
1467         }
1468         if (ut_params->ibuf) {
1469                 rte_pktmbuf_free(ut_params->ibuf);
1470                 ut_params->ibuf = 0;
1471         }
1472
1473         if (ts_params->mbuf_pool != NULL)
1474                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1475                         rte_mempool_avail_count(ts_params->mbuf_pool));
1476
1477         /* Stop the device */
1478         rte_cryptodev_stop(ts_params->valid_devs[0]);
1479 }
1480
1481 static int
1482 test_device_configure_invalid_dev_id(void)
1483 {
1484         struct crypto_testsuite_params *ts_params = &testsuite_params;
1485         uint16_t dev_id, num_devs = 0;
1486
1487         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1488                         "Need at least %d devices for test", 1);
1489
1490         /* valid dev_id values */
1491         dev_id = ts_params->valid_devs[0];
1492
1493         /* Stop the device in case it's started so it can be configured */
1494         rte_cryptodev_stop(dev_id);
1495
1496         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1497                         "Failed test for rte_cryptodev_configure: "
1498                         "invalid dev_num %u", dev_id);
1499
1500         /* invalid dev_id values */
1501         dev_id = num_devs;
1502
1503         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1504                         "Failed test for rte_cryptodev_configure: "
1505                         "invalid dev_num %u", dev_id);
1506
1507         dev_id = 0xff;
1508
1509         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1510                         "Failed test for rte_cryptodev_configure:"
1511                         "invalid dev_num %u", dev_id);
1512
1513         return TEST_SUCCESS;
1514 }
1515
1516 static int
1517 test_device_configure_invalid_queue_pair_ids(void)
1518 {
1519         struct crypto_testsuite_params *ts_params = &testsuite_params;
1520         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1521
1522         /* Stop the device in case it's started so it can be configured */
1523         rte_cryptodev_stop(ts_params->valid_devs[0]);
1524
1525         /* valid - max value queue pairs */
1526         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1527
1528         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1529                         &ts_params->conf),
1530                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1531                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1532
1533         /* valid - one queue pairs */
1534         ts_params->conf.nb_queue_pairs = 1;
1535
1536         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1537                         &ts_params->conf),
1538                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1539                         ts_params->valid_devs[0],
1540                         ts_params->conf.nb_queue_pairs);
1541
1542
1543         /* invalid - zero queue pairs */
1544         ts_params->conf.nb_queue_pairs = 0;
1545
1546         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1547                         &ts_params->conf),
1548                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1549                         " invalid qps: %u",
1550                         ts_params->valid_devs[0],
1551                         ts_params->conf.nb_queue_pairs);
1552
1553
1554         /* invalid - max value supported by field queue pairs */
1555         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1556
1557         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1558                         &ts_params->conf),
1559                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1560                         " invalid qps: %u",
1561                         ts_params->valid_devs[0],
1562                         ts_params->conf.nb_queue_pairs);
1563
1564
1565         /* invalid - max value + 1 queue pairs */
1566         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1567
1568         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1569                         &ts_params->conf),
1570                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1571                         " invalid qps: %u",
1572                         ts_params->valid_devs[0],
1573                         ts_params->conf.nb_queue_pairs);
1574
1575         /* revert to original testsuite value */
1576         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1577
1578         return TEST_SUCCESS;
1579 }
1580
1581 static int
1582 test_queue_pair_descriptor_setup(void)
1583 {
1584         struct crypto_testsuite_params *ts_params = &testsuite_params;
1585         struct rte_cryptodev_qp_conf qp_conf = {
1586                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1587         };
1588         uint16_t qp_id;
1589
1590         /* Stop the device in case it's started so it can be configured */
1591         rte_cryptodev_stop(ts_params->valid_devs[0]);
1592
1593         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1594                         &ts_params->conf),
1595                         "Failed to configure cryptodev %u",
1596                         ts_params->valid_devs[0]);
1597
1598         /*
1599          * Test various ring sizes on this device. memzones can't be
1600          * freed so are re-used if ring is released and re-created.
1601          */
1602         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1603         qp_conf.mp_session = ts_params->session_mpool;
1604         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1605
1606         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1607                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1608                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1609                                 rte_cryptodev_socket_id(
1610                                                 ts_params->valid_devs[0])),
1611                                 "Failed test for "
1612                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1613                                 "%u on qp %u on cryptodev %u",
1614                                 qp_conf.nb_descriptors, qp_id,
1615                                 ts_params->valid_devs[0]);
1616         }
1617
1618         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1619
1620         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1621                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1622                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1623                                 rte_cryptodev_socket_id(
1624                                                 ts_params->valid_devs[0])),
1625                                 "Failed test for"
1626                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1627                                 " %u on qp %u on cryptodev %u",
1628                                 qp_conf.nb_descriptors, qp_id,
1629                                 ts_params->valid_devs[0]);
1630         }
1631
1632         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1633
1634         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1635                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1636                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1637                                 rte_cryptodev_socket_id(
1638                                                 ts_params->valid_devs[0])),
1639                                 "Failed test for "
1640                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1641                                 " %u on qp %u on cryptodev %u",
1642                                 qp_conf.nb_descriptors, qp_id,
1643                                 ts_params->valid_devs[0]);
1644         }
1645
1646         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1647
1648         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1649                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1650                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1651                                 rte_cryptodev_socket_id(
1652                                                 ts_params->valid_devs[0])),
1653                                 "Failed test for"
1654                                 " rte_cryptodev_queue_pair_setup:"
1655                                 "num_inflights %u on qp %u on cryptodev %u",
1656                                 qp_conf.nb_descriptors, qp_id,
1657                                 ts_params->valid_devs[0]);
1658         }
1659
1660         /* test invalid queue pair id */
1661         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1662
1663         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1664
1665         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1666                         ts_params->valid_devs[0],
1667                         qp_id, &qp_conf,
1668                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1669                         "Failed test for rte_cryptodev_queue_pair_setup:"
1670                         "invalid qp %u on cryptodev %u",
1671                         qp_id, ts_params->valid_devs[0]);
1672
1673         qp_id = 0xffff; /*invalid*/
1674
1675         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1676                         ts_params->valid_devs[0],
1677                         qp_id, &qp_conf,
1678                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1679                         "Failed test for rte_cryptodev_queue_pair_setup:"
1680                         "invalid qp %u on cryptodev %u",
1681                         qp_id, ts_params->valid_devs[0]);
1682
1683         return TEST_SUCCESS;
1684 }
1685
1686 /* ***** Plaintext data for tests ***** */
1687
1688 const char catch_22_quote_1[] =
1689                 "There was only one catch and that was Catch-22, which "
1690                 "specified that a concern for one's safety in the face of "
1691                 "dangers that were real and immediate was the process of a "
1692                 "rational mind. Orr was crazy and could be grounded. All he "
1693                 "had to do was ask; and as soon as he did, he would no longer "
1694                 "be crazy and would have to fly more missions. Orr would be "
1695                 "crazy to fly more missions and sane if he didn't, but if he "
1696                 "was sane he had to fly them. If he flew them he was crazy "
1697                 "and didn't have to; but if he didn't want to he was sane and "
1698                 "had to. Yossarian was moved very deeply by the absolute "
1699                 "simplicity of this clause of Catch-22 and let out a "
1700                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1701                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1702
1703 const char catch_22_quote[] =
1704                 "What a lousy earth! He wondered how many people were "
1705                 "destitute that same night even in his own prosperous country, "
1706                 "how many homes were shanties, how many husbands were drunk "
1707                 "and wives socked, and how many children were bullied, abused, "
1708                 "or abandoned. How many families hungered for food they could "
1709                 "not afford to buy? How many hearts were broken? How many "
1710                 "suicides would take place that same night, how many people "
1711                 "would go insane? How many cockroaches and landlords would "
1712                 "triumph? How many winners were losers, successes failures, "
1713                 "and rich men poor men? How many wise guys were stupid? How "
1714                 "many happy endings were unhappy endings? How many honest men "
1715                 "were liars, brave men cowards, loyal men traitors, how many "
1716                 "sainted men were corrupt, how many people in positions of "
1717                 "trust had sold their souls to bodyguards, how many had never "
1718                 "had souls? How many straight-and-narrow paths were crooked "
1719                 "paths? How many best families were worst families and how "
1720                 "many good people were bad people? When you added them all up "
1721                 "and then subtracted, you might be left with only the children, "
1722                 "and perhaps with Albert Einstein and an old violinist or "
1723                 "sculptor somewhere.";
1724
1725 #define QUOTE_480_BYTES         (480)
1726 #define QUOTE_512_BYTES         (512)
1727 #define QUOTE_768_BYTES         (768)
1728 #define QUOTE_1024_BYTES        (1024)
1729
1730
1731
1732 /* ***** SHA1 Hash Tests ***** */
1733
1734 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1735
1736 static uint8_t hmac_sha1_key[] = {
1737         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1738         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1739         0xDE, 0xF4, 0xDE, 0xAD };
1740
1741 /* ***** SHA224 Hash Tests ***** */
1742
1743 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1744
1745
1746 /* ***** AES-CBC Cipher Tests ***** */
1747
1748 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1749 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1750
1751 static uint8_t aes_cbc_key[] = {
1752         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1753         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1754
1755 static uint8_t aes_cbc_iv[] = {
1756         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1757         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1758
1759
1760 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1761
1762 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1763         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1764         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1765         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1766         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1767         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1768         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1769         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1770         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1771         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1772         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1773         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1774         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1775         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1776         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1777         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1778         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1779         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1780         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1781         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1782         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1783         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1784         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1785         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1786         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1787         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1788         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1789         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1790         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1791         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1792         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1793         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1794         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1795         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1796         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1797         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1798         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1799         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1800         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1801         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1802         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1803         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1804         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1805         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1806         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1807         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1808         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1809         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1810         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1811         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1812         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1813         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1814         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1815         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1816         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1817         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1818         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1819         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1820         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1821         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1822         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1823         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1824         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1825         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1826         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1827 };
1828
1829 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1830         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1831         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1832         0x18, 0x8c, 0x1d, 0x32
1833 };
1834
1835
1836 /* Multisession Vector context Test */
1837 /*Begin Session 0 */
1838 static uint8_t ms_aes_cbc_key0[] = {
1839         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1840         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1841 };
1842
1843 static uint8_t ms_aes_cbc_iv0[] = {
1844         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1845         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1846 };
1847
1848 static const uint8_t ms_aes_cbc_cipher0[] = {
1849                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1850                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1851                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1852                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1853                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1854                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1855                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1856                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1857                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1858                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1859                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1860                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1861                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1862                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1863                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1864                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1865                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1866                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1867                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1868                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1869                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1870                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1871                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1872                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1873                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1874                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1875                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1876                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1877                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1878                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1879                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1880                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1881                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1882                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1883                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1884                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1885                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1886                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1887                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1888                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1889                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1890                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1891                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1892                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1893                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1894                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1895                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1896                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1897                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1898                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1899                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1900                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1901                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1902                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1903                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1904                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1905                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1906                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1907                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1908                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1909                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1910                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1911                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1912                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1913 };
1914
1915
1916 static  uint8_t ms_hmac_key0[] = {
1917                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1918                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1919                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1920                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1921                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1922                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1923                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1924                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1925 };
1926
1927 static const uint8_t ms_hmac_digest0[] = {
1928                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1929                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1930                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1931                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1932                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1933                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1934                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1935                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1936                 };
1937
1938 /* End Session 0 */
1939 /* Begin session 1 */
1940
1941 static  uint8_t ms_aes_cbc_key1[] = {
1942                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1943                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1944 };
1945
1946 static  uint8_t ms_aes_cbc_iv1[] = {
1947         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1948         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1949 };
1950
1951 static const uint8_t ms_aes_cbc_cipher1[] = {
1952                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1953                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1954                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1955                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1956                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1957                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1958                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1959                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1960                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1961                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1962                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1963                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1964                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1965                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1966                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1967                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1968                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1969                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1970                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1971                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1972                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1973                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1974                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1975                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1976                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1977                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1978                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1979                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1980                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1981                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1982                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1983                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1984                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1985                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1986                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1987                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1988                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1989                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1990                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1991                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1992                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1993                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1994                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1995                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1996                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1997                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1998                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
1999                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
2000                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
2001                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
2002                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
2003                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
2004                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
2005                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
2006                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
2007                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2008                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2009                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2010                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2011                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2012                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2013                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2014                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2015                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2016
2017 };
2018
2019 static uint8_t ms_hmac_key1[] = {
2020                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2021                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2022                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2023                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2024                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2025                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2026                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2027                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2028 };
2029
2030 static const uint8_t ms_hmac_digest1[] = {
2031                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2032                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2033                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2034                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2035                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2036                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2037                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2038                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2039 };
2040 /* End Session 1  */
2041 /* Begin Session 2 */
2042 static  uint8_t ms_aes_cbc_key2[] = {
2043                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2044                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2045 };
2046
2047 static  uint8_t ms_aes_cbc_iv2[] = {
2048                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2049                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2050 };
2051
2052 static const uint8_t ms_aes_cbc_cipher2[] = {
2053                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2054                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2055                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2056                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2057                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2058                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2059                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2060                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2061                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2062                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2063                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2064                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2065                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2066                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2067                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2068                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2069                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2070                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2071                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2072                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2073                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2074                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2075                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2076                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2077                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2078                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2079                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2080                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2081                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2082                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2083                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2084                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2085                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2086                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2087                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2088                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2089                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2090                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2091                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2092                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2093                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2094                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2095                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2096                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2097                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2098                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2099                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2100                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2101                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2102                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2103                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2104                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2105                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2106                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2107                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2108                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2109                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2110                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2111                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2112                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2113                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2114                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2115                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2116                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2117 };
2118
2119 static  uint8_t ms_hmac_key2[] = {
2120                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2121                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2122                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2123                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2124                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2125                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2126                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2127                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2128 };
2129
2130 static const uint8_t ms_hmac_digest2[] = {
2131                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2132                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2133                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2134                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2135                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2136                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2137                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2138                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2139 };
2140
2141 /* End Session 2 */
2142
2143
2144 static int
2145 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2146 {
2147         struct crypto_testsuite_params *ts_params = &testsuite_params;
2148         struct crypto_unittest_params *ut_params = &unittest_params;
2149         int status;
2150
2151         /* Verify the capabilities */
2152         struct rte_cryptodev_sym_capability_idx cap_idx;
2153         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2154         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2155         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2156                         &cap_idx) == NULL)
2157                 return TEST_SKIPPED;
2158         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2159         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2160         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2161                         &cap_idx) == NULL)
2162                 return TEST_SKIPPED;
2163
2164         /* Generate test mbuf data and space for digest */
2165         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2166                         catch_22_quote, QUOTE_512_BYTES, 0);
2167
2168         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2169                         DIGEST_BYTE_LENGTH_SHA1);
2170         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2171
2172         /* Setup Cipher Parameters */
2173         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2174         ut_params->cipher_xform.next = &ut_params->auth_xform;
2175
2176         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2177         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2178         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2179         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2180         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2181         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2182
2183         /* Setup HMAC Parameters */
2184         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2185
2186         ut_params->auth_xform.next = NULL;
2187
2188         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2189         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2190         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2191         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2192         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2193
2194         ut_params->sess = rte_cryptodev_sym_session_create(
2195                         ts_params->session_mpool);
2196         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2197
2198         /* Create crypto session*/
2199         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2200                         ut_params->sess, &ut_params->cipher_xform,
2201                         ts_params->session_priv_mpool);
2202
2203         if (status == -ENOTSUP)
2204                 return TEST_SKIPPED;
2205
2206         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2207
2208         /* Generate crypto op data structure */
2209         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2210                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2211         TEST_ASSERT_NOT_NULL(ut_params->op,
2212                         "Failed to allocate symmetric crypto operation struct");
2213
2214         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2215
2216         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2217
2218         /* set crypto operation source mbuf */
2219         sym_op->m_src = ut_params->ibuf;
2220
2221         /* Set crypto operation authentication parameters */
2222         sym_op->auth.digest.data = ut_params->digest;
2223         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2224                         ut_params->ibuf, QUOTE_512_BYTES);
2225
2226         sym_op->auth.data.offset = 0;
2227         sym_op->auth.data.length = QUOTE_512_BYTES;
2228
2229         /* Copy IV at the end of the crypto operation */
2230         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2231                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2232
2233         /* Set crypto operation cipher parameters */
2234         sym_op->cipher.data.offset = 0;
2235         sym_op->cipher.data.length = QUOTE_512_BYTES;
2236
2237         /* Process crypto operation */
2238         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2239                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2240                         ut_params->op);
2241         else
2242                 TEST_ASSERT_NOT_NULL(
2243                         process_crypto_request(ts_params->valid_devs[0],
2244                                 ut_params->op),
2245                                 "failed to process sym crypto op");
2246
2247         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2248                         "crypto op processing failed");
2249
2250         /* Validate obuf */
2251         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2252                         uint8_t *);
2253
2254         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2255                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2256                         QUOTE_512_BYTES,
2257                         "ciphertext data not as expected");
2258
2259         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2260
2261         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2262                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2263                         gbl_driver_id == rte_cryptodev_driver_id_get(
2264                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2265                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2266                                         DIGEST_BYTE_LENGTH_SHA1,
2267                         "Generated digest data not as expected");
2268
2269         return TEST_SUCCESS;
2270 }
2271
2272 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2273
2274 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2275
2276 static uint8_t hmac_sha512_key[] = {
2277         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2278         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2279         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2280         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2281         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2282         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2283         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2284         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2285
2286 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2287         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2288         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2289         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2290         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2291         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2292         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2293         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2294         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2295
2296
2297
2298 static int
2299 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2300                 struct crypto_unittest_params *ut_params,
2301                 uint8_t *cipher_key,
2302                 uint8_t *hmac_key);
2303
2304 static int
2305 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2306                 struct crypto_unittest_params *ut_params,
2307                 struct crypto_testsuite_params *ts_params,
2308                 const uint8_t *cipher,
2309                 const uint8_t *digest,
2310                 const uint8_t *iv);
2311
2312
2313 static int
2314 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2315                 struct crypto_unittest_params *ut_params,
2316                 uint8_t *cipher_key,
2317                 uint8_t *hmac_key)
2318 {
2319
2320         /* Setup Cipher Parameters */
2321         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2322         ut_params->cipher_xform.next = NULL;
2323
2324         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2325         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2326         ut_params->cipher_xform.cipher.key.data = cipher_key;
2327         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2328         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2329         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2330
2331         /* Setup HMAC Parameters */
2332         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2333         ut_params->auth_xform.next = &ut_params->cipher_xform;
2334
2335         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2336         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2337         ut_params->auth_xform.auth.key.data = hmac_key;
2338         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2339         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2340
2341         return TEST_SUCCESS;
2342 }
2343
2344
2345 static int
2346 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2347                 struct crypto_unittest_params *ut_params,
2348                 struct crypto_testsuite_params *ts_params,
2349                 const uint8_t *cipher,
2350                 const uint8_t *digest,
2351                 const uint8_t *iv)
2352 {
2353         /* Generate test mbuf data and digest */
2354         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2355                         (const char *)
2356                         cipher,
2357                         QUOTE_512_BYTES, 0);
2358
2359         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2360                         DIGEST_BYTE_LENGTH_SHA512);
2361         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2362
2363         rte_memcpy(ut_params->digest,
2364                         digest,
2365                         DIGEST_BYTE_LENGTH_SHA512);
2366
2367         /* Generate Crypto op data structure */
2368         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2369                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2370         TEST_ASSERT_NOT_NULL(ut_params->op,
2371                         "Failed to allocate symmetric crypto operation struct");
2372
2373         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2374
2375         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2376
2377         /* set crypto operation source mbuf */
2378         sym_op->m_src = ut_params->ibuf;
2379
2380         sym_op->auth.digest.data = ut_params->digest;
2381         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2382                         ut_params->ibuf, QUOTE_512_BYTES);
2383
2384         sym_op->auth.data.offset = 0;
2385         sym_op->auth.data.length = QUOTE_512_BYTES;
2386
2387         /* Copy IV at the end of the crypto operation */
2388         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2389                         iv, CIPHER_IV_LENGTH_AES_CBC);
2390
2391         sym_op->cipher.data.offset = 0;
2392         sym_op->cipher.data.length = QUOTE_512_BYTES;
2393
2394         /* Process crypto operation */
2395         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2396                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2397                         ut_params->op);
2398         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2399                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2400                                 ut_params->op, 1, 1, 0, 0);
2401         else
2402                 TEST_ASSERT_NOT_NULL(
2403                                 process_crypto_request(ts_params->valid_devs[0],
2404                                         ut_params->op),
2405                                         "failed to process sym crypto op");
2406
2407         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2408                         "crypto op processing failed");
2409
2410         ut_params->obuf = ut_params->op->sym->m_src;
2411
2412         /* Validate obuf */
2413         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2414                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2415                         catch_22_quote,
2416                         QUOTE_512_BYTES,
2417                         "Plaintext data not as expected");
2418
2419         /* Validate obuf */
2420         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2421                         "Digest verification failed");
2422
2423         return TEST_SUCCESS;
2424 }
2425
2426 /* ***** SNOW 3G Tests ***** */
2427 static int
2428 create_wireless_algo_hash_session(uint8_t dev_id,
2429         const uint8_t *key, const uint8_t key_len,
2430         const uint8_t iv_len, const uint8_t auth_len,
2431         enum rte_crypto_auth_operation op,
2432         enum rte_crypto_auth_algorithm algo)
2433 {
2434         uint8_t hash_key[key_len];
2435         int status;
2436
2437         struct crypto_testsuite_params *ts_params = &testsuite_params;
2438         struct crypto_unittest_params *ut_params = &unittest_params;
2439
2440         memcpy(hash_key, key, key_len);
2441
2442         debug_hexdump(stdout, "key:", key, key_len);
2443
2444         /* Setup Authentication Parameters */
2445         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2446         ut_params->auth_xform.next = NULL;
2447
2448         ut_params->auth_xform.auth.op = op;
2449         ut_params->auth_xform.auth.algo = algo;
2450         ut_params->auth_xform.auth.key.length = key_len;
2451         ut_params->auth_xform.auth.key.data = hash_key;
2452         ut_params->auth_xform.auth.digest_length = auth_len;
2453         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2454         ut_params->auth_xform.auth.iv.length = iv_len;
2455         ut_params->sess = rte_cryptodev_sym_session_create(
2456                         ts_params->session_mpool);
2457
2458         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2459                         &ut_params->auth_xform,
2460                         ts_params->session_priv_mpool);
2461         if (status == -ENOTSUP)
2462                 return TEST_SKIPPED;
2463
2464         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2465         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2466         return 0;
2467 }
2468
2469 static int
2470 create_wireless_algo_cipher_session(uint8_t dev_id,
2471                         enum rte_crypto_cipher_operation op,
2472                         enum rte_crypto_cipher_algorithm algo,
2473                         const uint8_t *key, const uint8_t key_len,
2474                         uint8_t iv_len)
2475 {
2476         uint8_t cipher_key[key_len];
2477         int status;
2478         struct crypto_testsuite_params *ts_params = &testsuite_params;
2479         struct crypto_unittest_params *ut_params = &unittest_params;
2480
2481         memcpy(cipher_key, key, key_len);
2482
2483         /* Setup Cipher Parameters */
2484         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2485         ut_params->cipher_xform.next = NULL;
2486
2487         ut_params->cipher_xform.cipher.algo = algo;
2488         ut_params->cipher_xform.cipher.op = op;
2489         ut_params->cipher_xform.cipher.key.data = cipher_key;
2490         ut_params->cipher_xform.cipher.key.length = key_len;
2491         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2492         ut_params->cipher_xform.cipher.iv.length = iv_len;
2493
2494         debug_hexdump(stdout, "key:", key, key_len);
2495
2496         /* Create Crypto session */
2497         ut_params->sess = rte_cryptodev_sym_session_create(
2498                         ts_params->session_mpool);
2499
2500         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2501                         &ut_params->cipher_xform,
2502                         ts_params->session_priv_mpool);
2503         if (status == -ENOTSUP)
2504                 return TEST_SKIPPED;
2505
2506         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2507         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2508         return 0;
2509 }
2510
2511 static int
2512 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2513                         unsigned int cipher_len,
2514                         unsigned int cipher_offset)
2515 {
2516         struct crypto_testsuite_params *ts_params = &testsuite_params;
2517         struct crypto_unittest_params *ut_params = &unittest_params;
2518
2519         /* Generate Crypto op data structure */
2520         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2521                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2522         TEST_ASSERT_NOT_NULL(ut_params->op,
2523                                 "Failed to allocate pktmbuf offload");
2524
2525         /* Set crypto operation data parameters */
2526         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2527
2528         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2529
2530         /* set crypto operation source mbuf */
2531         sym_op->m_src = ut_params->ibuf;
2532
2533         /* iv */
2534         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2535                         iv, iv_len);
2536         sym_op->cipher.data.length = cipher_len;
2537         sym_op->cipher.data.offset = cipher_offset;
2538         return 0;
2539 }
2540
2541 static int
2542 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2543                         unsigned int cipher_len,
2544                         unsigned int cipher_offset)
2545 {
2546         struct crypto_testsuite_params *ts_params = &testsuite_params;
2547         struct crypto_unittest_params *ut_params = &unittest_params;
2548
2549         /* Generate Crypto op data structure */
2550         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2551                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2552         TEST_ASSERT_NOT_NULL(ut_params->op,
2553                                 "Failed to allocate pktmbuf offload");
2554
2555         /* Set crypto operation data parameters */
2556         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2557
2558         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2559
2560         /* set crypto operation source mbuf */
2561         sym_op->m_src = ut_params->ibuf;
2562         sym_op->m_dst = ut_params->obuf;
2563
2564         /* iv */
2565         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2566                         iv, iv_len);
2567         sym_op->cipher.data.length = cipher_len;
2568         sym_op->cipher.data.offset = cipher_offset;
2569         return 0;
2570 }
2571
2572 static int
2573 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2574                 enum rte_crypto_cipher_operation cipher_op,
2575                 enum rte_crypto_auth_operation auth_op,
2576                 enum rte_crypto_auth_algorithm auth_algo,
2577                 enum rte_crypto_cipher_algorithm cipher_algo,
2578                 const uint8_t *key, uint8_t key_len,
2579                 uint8_t auth_iv_len, uint8_t auth_len,
2580                 uint8_t cipher_iv_len)
2581
2582 {
2583         uint8_t cipher_auth_key[key_len];
2584         int status;
2585
2586         struct crypto_testsuite_params *ts_params = &testsuite_params;
2587         struct crypto_unittest_params *ut_params = &unittest_params;
2588
2589         memcpy(cipher_auth_key, key, key_len);
2590
2591         /* Setup Authentication Parameters */
2592         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2593         ut_params->auth_xform.next = NULL;
2594
2595         ut_params->auth_xform.auth.op = auth_op;
2596         ut_params->auth_xform.auth.algo = auth_algo;
2597         ut_params->auth_xform.auth.key.length = key_len;
2598         /* Hash key = cipher key */
2599         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2600         ut_params->auth_xform.auth.digest_length = auth_len;
2601         /* Auth IV will be after cipher IV */
2602         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2603         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2604
2605         /* Setup Cipher Parameters */
2606         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2607         ut_params->cipher_xform.next = &ut_params->auth_xform;
2608
2609         ut_params->cipher_xform.cipher.algo = cipher_algo;
2610         ut_params->cipher_xform.cipher.op = cipher_op;
2611         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2612         ut_params->cipher_xform.cipher.key.length = key_len;
2613         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2614         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2615
2616         debug_hexdump(stdout, "key:", key, key_len);
2617
2618         /* Create Crypto session*/
2619         ut_params->sess = rte_cryptodev_sym_session_create(
2620                         ts_params->session_mpool);
2621         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2622
2623         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2624                         &ut_params->cipher_xform,
2625                         ts_params->session_priv_mpool);
2626         if (status == -ENOTSUP)
2627                 return TEST_SKIPPED;
2628
2629         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2630         return 0;
2631 }
2632
2633 static int
2634 create_wireless_cipher_auth_session(uint8_t dev_id,
2635                 enum rte_crypto_cipher_operation cipher_op,
2636                 enum rte_crypto_auth_operation auth_op,
2637                 enum rte_crypto_auth_algorithm auth_algo,
2638                 enum rte_crypto_cipher_algorithm cipher_algo,
2639                 const struct wireless_test_data *tdata)
2640 {
2641         const uint8_t key_len = tdata->key.len;
2642         uint8_t cipher_auth_key[key_len];
2643         int status;
2644
2645         struct crypto_testsuite_params *ts_params = &testsuite_params;
2646         struct crypto_unittest_params *ut_params = &unittest_params;
2647         const uint8_t *key = tdata->key.data;
2648         const uint8_t auth_len = tdata->digest.len;
2649         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2650         uint8_t auth_iv_len = tdata->auth_iv.len;
2651
2652         memcpy(cipher_auth_key, key, key_len);
2653
2654         /* Setup Authentication Parameters */
2655         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2656         ut_params->auth_xform.next = NULL;
2657
2658         ut_params->auth_xform.auth.op = auth_op;
2659         ut_params->auth_xform.auth.algo = auth_algo;
2660         ut_params->auth_xform.auth.key.length = key_len;
2661         /* Hash key = cipher key */
2662         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2663         ut_params->auth_xform.auth.digest_length = auth_len;
2664         /* Auth IV will be after cipher IV */
2665         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2666         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2667
2668         /* Setup Cipher Parameters */
2669         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2670         ut_params->cipher_xform.next = &ut_params->auth_xform;
2671
2672         ut_params->cipher_xform.cipher.algo = cipher_algo;
2673         ut_params->cipher_xform.cipher.op = cipher_op;
2674         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2675         ut_params->cipher_xform.cipher.key.length = key_len;
2676         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2677         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2678
2679
2680         debug_hexdump(stdout, "key:", key, key_len);
2681
2682         /* Create Crypto session*/
2683         ut_params->sess = rte_cryptodev_sym_session_create(
2684                         ts_params->session_mpool);
2685
2686         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2687                         &ut_params->cipher_xform,
2688                         ts_params->session_priv_mpool);
2689         if (status == -ENOTSUP)
2690                 return TEST_SKIPPED;
2691
2692         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2693         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2694         return 0;
2695 }
2696
2697 static int
2698 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2699                 const struct wireless_test_data *tdata)
2700 {
2701         return create_wireless_cipher_auth_session(dev_id,
2702                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2703                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2704                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2705 }
2706
2707 static int
2708 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2709                 enum rte_crypto_cipher_operation cipher_op,
2710                 enum rte_crypto_auth_operation auth_op,
2711                 enum rte_crypto_auth_algorithm auth_algo,
2712                 enum rte_crypto_cipher_algorithm cipher_algo,
2713                 const uint8_t *key, const uint8_t key_len,
2714                 uint8_t auth_iv_len, uint8_t auth_len,
2715                 uint8_t cipher_iv_len)
2716 {
2717         uint8_t auth_cipher_key[key_len];
2718         int status;
2719         struct crypto_testsuite_params *ts_params = &testsuite_params;
2720         struct crypto_unittest_params *ut_params = &unittest_params;
2721
2722         memcpy(auth_cipher_key, key, key_len);
2723
2724         /* Setup Authentication Parameters */
2725         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2726         ut_params->auth_xform.auth.op = auth_op;
2727         ut_params->auth_xform.next = &ut_params->cipher_xform;
2728         ut_params->auth_xform.auth.algo = auth_algo;
2729         ut_params->auth_xform.auth.key.length = key_len;
2730         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2731         ut_params->auth_xform.auth.digest_length = auth_len;
2732         /* Auth IV will be after cipher IV */
2733         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2734         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2735
2736         /* Setup Cipher Parameters */
2737         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2738         ut_params->cipher_xform.next = NULL;
2739         ut_params->cipher_xform.cipher.algo = cipher_algo;
2740         ut_params->cipher_xform.cipher.op = cipher_op;
2741         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2742         ut_params->cipher_xform.cipher.key.length = key_len;
2743         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2744         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2745
2746         debug_hexdump(stdout, "key:", key, key_len);
2747
2748         /* Create Crypto session*/
2749         ut_params->sess = rte_cryptodev_sym_session_create(
2750                         ts_params->session_mpool);
2751         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2752
2753         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2754                 ut_params->auth_xform.next = NULL;
2755                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2756                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2757                                 &ut_params->cipher_xform,
2758                                 ts_params->session_priv_mpool);
2759
2760         } else
2761                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2762                                 &ut_params->auth_xform,
2763                                 ts_params->session_priv_mpool);
2764
2765         if (status == -ENOTSUP)
2766                 return TEST_SKIPPED;
2767
2768         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2769
2770         return 0;
2771 }
2772
2773 static int
2774 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2775                 unsigned int auth_tag_len,
2776                 const uint8_t *iv, unsigned int iv_len,
2777                 unsigned int data_pad_len,
2778                 enum rte_crypto_auth_operation op,
2779                 unsigned int auth_len, unsigned int auth_offset)
2780 {
2781         struct crypto_testsuite_params *ts_params = &testsuite_params;
2782
2783         struct crypto_unittest_params *ut_params = &unittest_params;
2784
2785         /* Generate Crypto op data structure */
2786         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2787                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2788         TEST_ASSERT_NOT_NULL(ut_params->op,
2789                 "Failed to allocate pktmbuf offload");
2790
2791         /* Set crypto operation data parameters */
2792         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2793
2794         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2795
2796         /* set crypto operation source mbuf */
2797         sym_op->m_src = ut_params->ibuf;
2798
2799         /* iv */
2800         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2801                         iv, iv_len);
2802         /* digest */
2803         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2804                                         ut_params->ibuf, auth_tag_len);
2805
2806         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2807                                 "no room to append auth tag");
2808         ut_params->digest = sym_op->auth.digest.data;
2809         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2810                         ut_params->ibuf, data_pad_len);
2811         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2812                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2813         else
2814                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2815
2816         debug_hexdump(stdout, "digest:",
2817                 sym_op->auth.digest.data,
2818                 auth_tag_len);
2819
2820         sym_op->auth.data.length = auth_len;
2821         sym_op->auth.data.offset = auth_offset;
2822
2823         return 0;
2824 }
2825
2826 static int
2827 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2828         enum rte_crypto_auth_operation op)
2829 {
2830         struct crypto_testsuite_params *ts_params = &testsuite_params;
2831         struct crypto_unittest_params *ut_params = &unittest_params;
2832
2833         const uint8_t *auth_tag = tdata->digest.data;
2834         const unsigned int auth_tag_len = tdata->digest.len;
2835         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2836         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2837
2838         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2839         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2840         const uint8_t *auth_iv = tdata->auth_iv.data;
2841         const uint8_t auth_iv_len = tdata->auth_iv.len;
2842         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2843         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2844
2845         /* Generate Crypto op data structure */
2846         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2847                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2848         TEST_ASSERT_NOT_NULL(ut_params->op,
2849                         "Failed to allocate pktmbuf offload");
2850         /* Set crypto operation data parameters */
2851         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2852
2853         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2854
2855         /* set crypto operation source mbuf */
2856         sym_op->m_src = ut_params->ibuf;
2857
2858         /* digest */
2859         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2860                         ut_params->ibuf, auth_tag_len);
2861
2862         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2863                         "no room to append auth tag");
2864         ut_params->digest = sym_op->auth.digest.data;
2865         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2866                         ut_params->ibuf, data_pad_len);
2867         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2868                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2869         else
2870                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2871
2872         debug_hexdump(stdout, "digest:",
2873                 sym_op->auth.digest.data,
2874                 auth_tag_len);
2875
2876         /* Copy cipher and auth IVs at the end of the crypto operation */
2877         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2878                                                 IV_OFFSET);
2879         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2880         iv_ptr += cipher_iv_len;
2881         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2882
2883         sym_op->cipher.data.length = cipher_len;
2884         sym_op->cipher.data.offset = 0;
2885         sym_op->auth.data.length = auth_len;
2886         sym_op->auth.data.offset = 0;
2887
2888         return 0;
2889 }
2890
2891 static int
2892 create_zuc_cipher_hash_generate_operation(
2893                 const struct wireless_test_data *tdata)
2894 {
2895         return create_wireless_cipher_hash_operation(tdata,
2896                 RTE_CRYPTO_AUTH_OP_GENERATE);
2897 }
2898
2899 static int
2900 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2901                 const unsigned auth_tag_len,
2902                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2903                 unsigned data_pad_len,
2904                 enum rte_crypto_auth_operation op,
2905                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2906                 const unsigned cipher_len, const unsigned cipher_offset,
2907                 const unsigned auth_len, const unsigned auth_offset)
2908 {
2909         struct crypto_testsuite_params *ts_params = &testsuite_params;
2910         struct crypto_unittest_params *ut_params = &unittest_params;
2911
2912         enum rte_crypto_cipher_algorithm cipher_algo =
2913                         ut_params->cipher_xform.cipher.algo;
2914         enum rte_crypto_auth_algorithm auth_algo =
2915                         ut_params->auth_xform.auth.algo;
2916
2917         /* Generate Crypto op data structure */
2918         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2919                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2920         TEST_ASSERT_NOT_NULL(ut_params->op,
2921                         "Failed to allocate pktmbuf offload");
2922         /* Set crypto operation data parameters */
2923         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2924
2925         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2926
2927         /* set crypto operation source mbuf */
2928         sym_op->m_src = ut_params->ibuf;
2929
2930         /* digest */
2931         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2932                         ut_params->ibuf, auth_tag_len);
2933
2934         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2935                         "no room to append auth tag");
2936         ut_params->digest = sym_op->auth.digest.data;
2937
2938         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2939                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2940                                 ut_params->ibuf, data_pad_len);
2941         } else {
2942                 struct rte_mbuf *m = ut_params->ibuf;
2943                 unsigned int offset = data_pad_len;
2944
2945                 while (offset > m->data_len && m->next != NULL) {
2946                         offset -= m->data_len;
2947                         m = m->next;
2948                 }
2949                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2950                         m, offset);
2951         }
2952
2953         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2954                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2955         else
2956                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2957
2958         debug_hexdump(stdout, "digest:",
2959                 sym_op->auth.digest.data,
2960                 auth_tag_len);
2961
2962         /* Copy cipher and auth IVs at the end of the crypto operation */
2963         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2964                                                 IV_OFFSET);
2965         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2966         iv_ptr += cipher_iv_len;
2967         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2968
2969         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2970                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2971                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2972                 sym_op->cipher.data.length = cipher_len;
2973                 sym_op->cipher.data.offset = cipher_offset;
2974         } else {
2975                 sym_op->cipher.data.length = cipher_len >> 3;
2976                 sym_op->cipher.data.offset = cipher_offset >> 3;
2977         }
2978
2979         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2980                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2981                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2982                 sym_op->auth.data.length = auth_len;
2983                 sym_op->auth.data.offset = auth_offset;
2984         } else {
2985                 sym_op->auth.data.length = auth_len >> 3;
2986                 sym_op->auth.data.offset = auth_offset >> 3;
2987         }
2988
2989         return 0;
2990 }
2991
2992 static int
2993 create_wireless_algo_auth_cipher_operation(
2994                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2995                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2996                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2997                 unsigned int data_pad_len,
2998                 unsigned int cipher_len, unsigned int cipher_offset,
2999                 unsigned int auth_len, unsigned int auth_offset,
3000                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3001 {
3002         struct crypto_testsuite_params *ts_params = &testsuite_params;
3003         struct crypto_unittest_params *ut_params = &unittest_params;
3004
3005         enum rte_crypto_cipher_algorithm cipher_algo =
3006                         ut_params->cipher_xform.cipher.algo;
3007         enum rte_crypto_auth_algorithm auth_algo =
3008                         ut_params->auth_xform.auth.algo;
3009
3010         /* Generate Crypto op data structure */
3011         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3012                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3013         TEST_ASSERT_NOT_NULL(ut_params->op,
3014                         "Failed to allocate pktmbuf offload");
3015
3016         /* Set crypto operation data parameters */
3017         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3018
3019         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3020
3021         /* set crypto operation mbufs */
3022         sym_op->m_src = ut_params->ibuf;
3023         if (op_mode == OUT_OF_PLACE)
3024                 sym_op->m_dst = ut_params->obuf;
3025
3026         /* digest */
3027         if (!do_sgl) {
3028                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3029                         (op_mode == IN_PLACE ?
3030                                 ut_params->ibuf : ut_params->obuf),
3031                         uint8_t *, data_pad_len);
3032                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3033                         (op_mode == IN_PLACE ?
3034                                 ut_params->ibuf : ut_params->obuf),
3035                         data_pad_len);
3036                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3037         } else {
3038                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3039                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3040                                 sym_op->m_src : sym_op->m_dst);
3041                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3042                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3043                         sgl_buf = sgl_buf->next;
3044                 }
3045                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3046                                 uint8_t *, remaining_off);
3047                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3048                                 remaining_off);
3049                 memset(sym_op->auth.digest.data, 0, remaining_off);
3050                 while (sgl_buf->next != NULL) {
3051                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3052                                 0, rte_pktmbuf_data_len(sgl_buf));
3053                         sgl_buf = sgl_buf->next;
3054                 }
3055         }
3056
3057         /* Copy digest for the verification */
3058         if (verify)
3059                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3060
3061         /* Copy cipher and auth IVs at the end of the crypto operation */
3062         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3063                         ut_params->op, uint8_t *, IV_OFFSET);
3064
3065         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3066         iv_ptr += cipher_iv_len;
3067         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3068
3069         /* Only copy over the offset data needed from src to dst in OOP,
3070          * if the auth and cipher offsets are not aligned
3071          */
3072         if (op_mode == OUT_OF_PLACE) {
3073                 if (cipher_offset > auth_offset)
3074                         rte_memcpy(
3075                                 rte_pktmbuf_mtod_offset(
3076                                         sym_op->m_dst,
3077                                         uint8_t *, auth_offset >> 3),
3078                                 rte_pktmbuf_mtod_offset(
3079                                         sym_op->m_src,
3080                                         uint8_t *, auth_offset >> 3),
3081                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3082         }
3083
3084         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3085                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3086                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3087                 sym_op->cipher.data.length = cipher_len;
3088                 sym_op->cipher.data.offset = cipher_offset;
3089         } else {
3090                 sym_op->cipher.data.length = cipher_len >> 3;
3091                 sym_op->cipher.data.offset = cipher_offset >> 3;
3092         }
3093
3094         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3095                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3096                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3097                 sym_op->auth.data.length = auth_len;
3098                 sym_op->auth.data.offset = auth_offset;
3099         } else {
3100                 sym_op->auth.data.length = auth_len >> 3;
3101                 sym_op->auth.data.offset = auth_offset >> 3;
3102         }
3103
3104         return 0;
3105 }
3106
3107 static int
3108 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3109 {
3110         struct crypto_testsuite_params *ts_params = &testsuite_params;
3111         struct crypto_unittest_params *ut_params = &unittest_params;
3112
3113         int retval;
3114         unsigned plaintext_pad_len;
3115         unsigned plaintext_len;
3116         uint8_t *plaintext;
3117         struct rte_cryptodev_info dev_info;
3118
3119         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3120         uint64_t feat_flags = dev_info.feature_flags;
3121
3122         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3123                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3124                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3125                 return TEST_SKIPPED;
3126         }
3127
3128         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3129                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3130                 printf("Device doesn't support RAW data-path APIs.\n");
3131                 return TEST_SKIPPED;
3132         }
3133
3134         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3135                 return TEST_SKIPPED;
3136
3137         /* Verify the capabilities */
3138         struct rte_cryptodev_sym_capability_idx cap_idx;
3139         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3140         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3141         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3142                         &cap_idx) == NULL)
3143                 return TEST_SKIPPED;
3144
3145         /* Create SNOW 3G session */
3146         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3147                         tdata->key.data, tdata->key.len,
3148                         tdata->auth_iv.len, tdata->digest.len,
3149                         RTE_CRYPTO_AUTH_OP_GENERATE,
3150                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3151         if (retval < 0)
3152                 return retval;
3153
3154         /* alloc mbuf and set payload */
3155         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3156
3157         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3158         rte_pktmbuf_tailroom(ut_params->ibuf));
3159
3160         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3161         /* Append data which is padded to a multiple of */
3162         /* the algorithms block size */
3163         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3164         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3165                                 plaintext_pad_len);
3166         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3167
3168         /* Create SNOW 3G operation */
3169         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3170                         tdata->auth_iv.data, tdata->auth_iv.len,
3171                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3172                         tdata->validAuthLenInBits.len,
3173                         0);
3174         if (retval < 0)
3175                 return retval;
3176
3177         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3178                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3179                                 ut_params->op, 0, 1, 1, 0);
3180         else
3181                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3182                                 ut_params->op);
3183         ut_params->obuf = ut_params->op->sym->m_src;
3184         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3185         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3186                         + plaintext_pad_len;
3187
3188         /* Validate obuf */
3189         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3190         ut_params->digest,
3191         tdata->digest.data,
3192         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3193         "SNOW 3G Generated auth tag not as expected");
3194
3195         return 0;
3196 }
3197
3198 static int
3199 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3200 {
3201         struct crypto_testsuite_params *ts_params = &testsuite_params;
3202         struct crypto_unittest_params *ut_params = &unittest_params;
3203
3204         int retval;
3205         unsigned plaintext_pad_len;
3206         unsigned plaintext_len;
3207         uint8_t *plaintext;
3208         struct rte_cryptodev_info dev_info;
3209
3210         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3211         uint64_t feat_flags = dev_info.feature_flags;
3212
3213         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3214                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3215                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3216                 return TEST_SKIPPED;
3217         }
3218
3219         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3220                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3221                 printf("Device doesn't support RAW data-path APIs.\n");
3222                 return TEST_SKIPPED;
3223         }
3224
3225         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3226                 return TEST_SKIPPED;
3227
3228         /* Verify the capabilities */
3229         struct rte_cryptodev_sym_capability_idx cap_idx;
3230         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3231         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3232         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3233                         &cap_idx) == NULL)
3234                 return TEST_SKIPPED;
3235
3236         /* Create SNOW 3G session */
3237         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3238                                 tdata->key.data, tdata->key.len,
3239                                 tdata->auth_iv.len, tdata->digest.len,
3240                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3241                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3242         if (retval < 0)
3243                 return retval;
3244         /* alloc mbuf and set payload */
3245         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3246
3247         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3248         rte_pktmbuf_tailroom(ut_params->ibuf));
3249
3250         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3251         /* Append data which is padded to a multiple of */
3252         /* the algorithms block size */
3253         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3254         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3255                                 plaintext_pad_len);
3256         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3257
3258         /* Create SNOW 3G operation */
3259         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3260                         tdata->digest.len,
3261                         tdata->auth_iv.data, tdata->auth_iv.len,
3262                         plaintext_pad_len,
3263                         RTE_CRYPTO_AUTH_OP_VERIFY,
3264                         tdata->validAuthLenInBits.len,
3265                         0);
3266         if (retval < 0)
3267                 return retval;
3268
3269         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3270                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3271                                 ut_params->op, 0, 1, 1, 0);
3272         else
3273                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3274                                 ut_params->op);
3275         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3276         ut_params->obuf = ut_params->op->sym->m_src;
3277         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3278                                 + plaintext_pad_len;
3279
3280         /* Validate obuf */
3281         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3282                 return 0;
3283         else
3284                 return -1;
3285
3286         return 0;
3287 }
3288
3289 static int
3290 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3291 {
3292         struct crypto_testsuite_params *ts_params = &testsuite_params;
3293         struct crypto_unittest_params *ut_params = &unittest_params;
3294
3295         int retval;
3296         unsigned plaintext_pad_len;
3297         unsigned plaintext_len;
3298         uint8_t *plaintext;
3299         struct rte_cryptodev_info dev_info;
3300
3301         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3302         uint64_t feat_flags = dev_info.feature_flags;
3303
3304         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3305                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3306                 printf("Device doesn't support RAW data-path APIs.\n");
3307                 return TEST_SKIPPED;
3308         }
3309
3310         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3311                 return TEST_SKIPPED;
3312
3313         /* Verify the capabilities */
3314         struct rte_cryptodev_sym_capability_idx cap_idx;
3315         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3316         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3317         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3318                         &cap_idx) == NULL)
3319                 return TEST_SKIPPED;
3320
3321         /* Create KASUMI session */
3322         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3323                         tdata->key.data, tdata->key.len,
3324                         0, tdata->digest.len,
3325                         RTE_CRYPTO_AUTH_OP_GENERATE,
3326                         RTE_CRYPTO_AUTH_KASUMI_F9);
3327         if (retval < 0)
3328                 return retval;
3329
3330         /* alloc mbuf and set payload */
3331         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3332
3333         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3334         rte_pktmbuf_tailroom(ut_params->ibuf));
3335
3336         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3337         /* Append data which is padded to a multiple of */
3338         /* the algorithms block size */
3339         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3340         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3341                                 plaintext_pad_len);
3342         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3343
3344         /* Create KASUMI operation */
3345         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3346                         NULL, 0,
3347                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3348                         tdata->plaintext.len,
3349                         0);
3350         if (retval < 0)
3351                 return retval;
3352
3353         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3354                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3355                         ut_params->op);
3356         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3357                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3358                                 ut_params->op, 0, 1, 1, 0);
3359         else
3360                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3361                         ut_params->op);
3362
3363         ut_params->obuf = ut_params->op->sym->m_src;
3364         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3365         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3366                         + plaintext_pad_len;
3367
3368         /* Validate obuf */
3369         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3370         ut_params->digest,
3371         tdata->digest.data,
3372         DIGEST_BYTE_LENGTH_KASUMI_F9,
3373         "KASUMI Generated auth tag not as expected");
3374
3375         return 0;
3376 }
3377
3378 static int
3379 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3380 {
3381         struct crypto_testsuite_params *ts_params = &testsuite_params;
3382         struct crypto_unittest_params *ut_params = &unittest_params;
3383
3384         int retval;
3385         unsigned plaintext_pad_len;
3386         unsigned plaintext_len;
3387         uint8_t *plaintext;
3388         struct rte_cryptodev_info dev_info;
3389
3390         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3391         uint64_t feat_flags = dev_info.feature_flags;
3392
3393         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3394                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3395                 printf("Device doesn't support RAW data-path APIs.\n");
3396                 return TEST_SKIPPED;
3397         }
3398
3399         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3400                 return TEST_SKIPPED;
3401
3402         /* Verify the capabilities */
3403         struct rte_cryptodev_sym_capability_idx cap_idx;
3404         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3405         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3406         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3407                         &cap_idx) == NULL)
3408                 return TEST_SKIPPED;
3409
3410         /* Create KASUMI session */
3411         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3412                                 tdata->key.data, tdata->key.len,
3413                                 0, tdata->digest.len,
3414                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3415                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3416         if (retval < 0)
3417                 return retval;
3418         /* alloc mbuf and set payload */
3419         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3420
3421         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3422         rte_pktmbuf_tailroom(ut_params->ibuf));
3423
3424         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3425         /* Append data which is padded to a multiple */
3426         /* of the algorithms block size */
3427         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3428         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3429                                 plaintext_pad_len);
3430         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3431
3432         /* Create KASUMI operation */
3433         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3434                         tdata->digest.len,
3435                         NULL, 0,
3436                         plaintext_pad_len,
3437                         RTE_CRYPTO_AUTH_OP_VERIFY,
3438                         tdata->plaintext.len,
3439                         0);
3440         if (retval < 0)
3441                 return retval;
3442
3443         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3444                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3445                                 ut_params->op, 0, 1, 1, 0);
3446         else
3447                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3448                                 ut_params->op);
3449         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3450         ut_params->obuf = ut_params->op->sym->m_src;
3451         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3452                                 + plaintext_pad_len;
3453
3454         /* Validate obuf */
3455         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3456                 return 0;
3457         else
3458                 return -1;
3459
3460         return 0;
3461 }
3462
3463 static int
3464 test_snow3g_hash_generate_test_case_1(void)
3465 {
3466         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3467 }
3468
3469 static int
3470 test_snow3g_hash_generate_test_case_2(void)
3471 {
3472         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3473 }
3474
3475 static int
3476 test_snow3g_hash_generate_test_case_3(void)
3477 {
3478         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3479 }
3480
3481 static int
3482 test_snow3g_hash_generate_test_case_4(void)
3483 {
3484         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3485 }
3486
3487 static int
3488 test_snow3g_hash_generate_test_case_5(void)
3489 {
3490         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3491 }
3492
3493 static int
3494 test_snow3g_hash_generate_test_case_6(void)
3495 {
3496         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3497 }
3498
3499 static int
3500 test_snow3g_hash_verify_test_case_1(void)
3501 {
3502         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3503
3504 }
3505
3506 static int
3507 test_snow3g_hash_verify_test_case_2(void)
3508 {
3509         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3510 }
3511
3512 static int
3513 test_snow3g_hash_verify_test_case_3(void)
3514 {
3515         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3516 }
3517
3518 static int
3519 test_snow3g_hash_verify_test_case_4(void)
3520 {
3521         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3522 }
3523
3524 static int
3525 test_snow3g_hash_verify_test_case_5(void)
3526 {
3527         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3528 }
3529
3530 static int
3531 test_snow3g_hash_verify_test_case_6(void)
3532 {
3533         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3534 }
3535
3536 static int
3537 test_kasumi_hash_generate_test_case_1(void)
3538 {
3539         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3540 }
3541
3542 static int
3543 test_kasumi_hash_generate_test_case_2(void)
3544 {
3545         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3546 }
3547
3548 static int
3549 test_kasumi_hash_generate_test_case_3(void)
3550 {
3551         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3552 }
3553
3554 static int
3555 test_kasumi_hash_generate_test_case_4(void)
3556 {
3557         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3558 }
3559
3560 static int
3561 test_kasumi_hash_generate_test_case_5(void)
3562 {
3563         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3564 }
3565
3566 static int
3567 test_kasumi_hash_generate_test_case_6(void)
3568 {
3569         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3570 }
3571
3572 static int
3573 test_kasumi_hash_verify_test_case_1(void)
3574 {
3575         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3576 }
3577
3578 static int
3579 test_kasumi_hash_verify_test_case_2(void)
3580 {
3581         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3582 }
3583
3584 static int
3585 test_kasumi_hash_verify_test_case_3(void)
3586 {
3587         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3588 }
3589
3590 static int
3591 test_kasumi_hash_verify_test_case_4(void)
3592 {
3593         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3594 }
3595
3596 static int
3597 test_kasumi_hash_verify_test_case_5(void)
3598 {
3599         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3600 }
3601
3602 static int
3603 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3604 {
3605         struct crypto_testsuite_params *ts_params = &testsuite_params;
3606         struct crypto_unittest_params *ut_params = &unittest_params;
3607
3608         int retval;
3609         uint8_t *plaintext, *ciphertext;
3610         unsigned plaintext_pad_len;
3611         unsigned plaintext_len;
3612         struct rte_cryptodev_info dev_info;
3613
3614         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3615         uint64_t feat_flags = dev_info.feature_flags;
3616
3617         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3618                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3619                 printf("Device doesn't support RAW data-path APIs.\n");
3620                 return TEST_SKIPPED;
3621         }
3622
3623         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3624                 return TEST_SKIPPED;
3625
3626         /* Verify the capabilities */
3627         struct rte_cryptodev_sym_capability_idx cap_idx;
3628         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3629         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3630         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3631                         &cap_idx) == NULL)
3632                 return TEST_SKIPPED;
3633
3634         /* Create KASUMI session */
3635         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3636                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3637                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3638                                         tdata->key.data, tdata->key.len,
3639                                         tdata->cipher_iv.len);
3640         if (retval < 0)
3641                 return retval;
3642
3643         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3644
3645         /* Clear mbuf payload */
3646         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3647                rte_pktmbuf_tailroom(ut_params->ibuf));
3648
3649         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3650         /* Append data which is padded to a multiple */
3651         /* of the algorithms block size */
3652         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3653         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3654                                 plaintext_pad_len);
3655         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3656
3657         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3658
3659         /* Create KASUMI operation */
3660         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3661                                 tdata->cipher_iv.len,
3662                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3663                                 tdata->validCipherOffsetInBits.len);
3664         if (retval < 0)
3665                 return retval;
3666
3667         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3668                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3669                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3670         else
3671                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3672                                 ut_params->op);
3673         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3674
3675         ut_params->obuf = ut_params->op->sym->m_dst;
3676         if (ut_params->obuf)
3677                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3678         else
3679                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3680
3681         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3682
3683         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3684                                 (tdata->validCipherOffsetInBits.len >> 3);
3685         /* Validate obuf */
3686         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3687                 ciphertext,
3688                 reference_ciphertext,
3689                 tdata->validCipherLenInBits.len,
3690                 "KASUMI Ciphertext data not as expected");
3691         return 0;
3692 }
3693
3694 static int
3695 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3696 {
3697         struct crypto_testsuite_params *ts_params = &testsuite_params;
3698         struct crypto_unittest_params *ut_params = &unittest_params;
3699
3700         int retval;
3701
3702         unsigned int plaintext_pad_len;
3703         unsigned int plaintext_len;
3704
3705         uint8_t buffer[10000];
3706         const uint8_t *ciphertext;
3707
3708         struct rte_cryptodev_info dev_info;
3709
3710         /* Verify the capabilities */
3711         struct rte_cryptodev_sym_capability_idx cap_idx;
3712         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3713         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3714         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3715                         &cap_idx) == NULL)
3716                 return TEST_SKIPPED;
3717
3718         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3719
3720         uint64_t feat_flags = dev_info.feature_flags;
3721
3722         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3723                 printf("Device doesn't support in-place scatter-gather. "
3724                                 "Test Skipped.\n");
3725                 return TEST_SKIPPED;
3726         }
3727
3728         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3729                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3730                 printf("Device doesn't support RAW data-path APIs.\n");
3731                 return TEST_SKIPPED;
3732         }
3733
3734         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3735                 return TEST_SKIPPED;
3736
3737         /* Create KASUMI session */
3738         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3739                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3740                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3741                                         tdata->key.data, tdata->key.len,
3742                                         tdata->cipher_iv.len);
3743         if (retval < 0)
3744                 return retval;
3745
3746         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3747
3748
3749         /* Append data which is padded to a multiple */
3750         /* of the algorithms block size */
3751         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3752
3753         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3754                         plaintext_pad_len, 10, 0);
3755
3756         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3757
3758         /* Create KASUMI operation */
3759         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3760                                 tdata->cipher_iv.len,
3761                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3762                                 tdata->validCipherOffsetInBits.len);
3763         if (retval < 0)
3764                 return retval;
3765
3766         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3767                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3768                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3769         else
3770                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3771                                                 ut_params->op);
3772         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3773
3774         ut_params->obuf = ut_params->op->sym->m_dst;
3775
3776         if (ut_params->obuf)
3777                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3778                                 plaintext_len, buffer);
3779         else
3780                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3781                                 tdata->validCipherOffsetInBits.len >> 3,
3782                                 plaintext_len, buffer);
3783
3784         /* Validate obuf */
3785         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3786
3787         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3788                                 (tdata->validCipherOffsetInBits.len >> 3);
3789         /* Validate obuf */
3790         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3791                 ciphertext,
3792                 reference_ciphertext,
3793                 tdata->validCipherLenInBits.len,
3794                 "KASUMI Ciphertext data not as expected");
3795         return 0;
3796 }
3797
3798 static int
3799 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3800 {
3801         struct crypto_testsuite_params *ts_params = &testsuite_params;
3802         struct crypto_unittest_params *ut_params = &unittest_params;
3803
3804         int retval;
3805         uint8_t *plaintext, *ciphertext;
3806         unsigned plaintext_pad_len;
3807         unsigned plaintext_len;
3808
3809         /* Verify the capabilities */
3810         struct rte_cryptodev_sym_capability_idx cap_idx;
3811         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3812         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3813         /* Data-path service does not support OOP */
3814         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3815                         &cap_idx) == NULL)
3816                 return TEST_SKIPPED;
3817
3818         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3819                 return TEST_SKIPPED;
3820
3821         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3822                 return TEST_SKIPPED;
3823
3824         /* Create KASUMI session */
3825         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3826                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3827                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3828                                         tdata->key.data, tdata->key.len,
3829                                         tdata->cipher_iv.len);
3830         if (retval < 0)
3831                 return retval;
3832
3833         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3834         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3835
3836         /* Clear mbuf payload */
3837         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3838                rte_pktmbuf_tailroom(ut_params->ibuf));
3839
3840         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3841         /* Append data which is padded to a multiple */
3842         /* of the algorithms block size */
3843         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3844         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3845                                 plaintext_pad_len);
3846         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3847         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3848
3849         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3850
3851         /* Create KASUMI operation */
3852         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3853                                 tdata->cipher_iv.len,
3854                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3855                                 tdata->validCipherOffsetInBits.len);
3856         if (retval < 0)
3857                 return retval;
3858
3859         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3860                                                 ut_params->op);
3861         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3862
3863         ut_params->obuf = ut_params->op->sym->m_dst;
3864         if (ut_params->obuf)
3865                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3866         else
3867                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3868
3869         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3870
3871         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3872                                 (tdata->validCipherOffsetInBits.len >> 3);
3873         /* Validate obuf */
3874         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3875                 ciphertext,
3876                 reference_ciphertext,
3877                 tdata->validCipherLenInBits.len,
3878                 "KASUMI Ciphertext data not as expected");
3879         return 0;
3880 }
3881
3882 static int
3883 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3884 {
3885         struct crypto_testsuite_params *ts_params = &testsuite_params;
3886         struct crypto_unittest_params *ut_params = &unittest_params;
3887
3888         int retval;
3889         unsigned int plaintext_pad_len;
3890         unsigned int plaintext_len;
3891
3892         const uint8_t *ciphertext;
3893         uint8_t buffer[2048];
3894
3895         struct rte_cryptodev_info dev_info;
3896
3897         /* Verify the capabilities */
3898         struct rte_cryptodev_sym_capability_idx cap_idx;
3899         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3900         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3901         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3902                         &cap_idx) == NULL)
3903                 return TEST_SKIPPED;
3904
3905         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3906                 return TEST_SKIPPED;
3907
3908         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3909                 return TEST_SKIPPED;
3910
3911         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3912
3913         uint64_t feat_flags = dev_info.feature_flags;
3914         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3915                 printf("Device doesn't support out-of-place scatter-gather "
3916                                 "in both input and output mbufs. "
3917                                 "Test Skipped.\n");
3918                 return TEST_SKIPPED;
3919         }
3920
3921         /* Create KASUMI session */
3922         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3923                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3924                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3925                                         tdata->key.data, tdata->key.len,
3926                                         tdata->cipher_iv.len);
3927         if (retval < 0)
3928                 return retval;
3929
3930         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3931         /* Append data which is padded to a multiple */
3932         /* of the algorithms block size */
3933         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3934
3935         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3936                         plaintext_pad_len, 10, 0);
3937         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3938                         plaintext_pad_len, 3, 0);
3939
3940         /* Append data which is padded to a multiple */
3941         /* of the algorithms block size */
3942         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3943
3944         /* Create KASUMI operation */
3945         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3946                                 tdata->cipher_iv.len,
3947                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3948                                 tdata->validCipherOffsetInBits.len);
3949         if (retval < 0)
3950                 return retval;
3951
3952         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3953                                                 ut_params->op);
3954         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3955
3956         ut_params->obuf = ut_params->op->sym->m_dst;
3957         if (ut_params->obuf)
3958                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3959                                 plaintext_pad_len, buffer);
3960         else
3961                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3962                                 tdata->validCipherOffsetInBits.len >> 3,
3963                                 plaintext_pad_len, buffer);
3964
3965         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3966                                 (tdata->validCipherOffsetInBits.len >> 3);
3967         /* Validate obuf */
3968         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3969                 ciphertext,
3970                 reference_ciphertext,
3971                 tdata->validCipherLenInBits.len,
3972                 "KASUMI Ciphertext data not as expected");
3973         return 0;
3974 }
3975
3976
3977 static int
3978 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3979 {
3980         struct crypto_testsuite_params *ts_params = &testsuite_params;
3981         struct crypto_unittest_params *ut_params = &unittest_params;
3982
3983         int retval;
3984         uint8_t *ciphertext, *plaintext;
3985         unsigned ciphertext_pad_len;
3986         unsigned ciphertext_len;
3987
3988         /* Verify the capabilities */
3989         struct rte_cryptodev_sym_capability_idx cap_idx;
3990         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3991         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3992         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3993                         &cap_idx) == NULL)
3994                 return TEST_SKIPPED;
3995
3996         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3997                 return TEST_SKIPPED;
3998
3999         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4000                 return TEST_SKIPPED;
4001
4002         /* Create KASUMI session */
4003         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4004                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4005                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4006                                         tdata->key.data, tdata->key.len,
4007                                         tdata->cipher_iv.len);
4008         if (retval < 0)
4009                 return retval;
4010
4011         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4012         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4013
4014         /* Clear mbuf payload */
4015         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4016                rte_pktmbuf_tailroom(ut_params->ibuf));
4017
4018         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4019         /* Append data which is padded to a multiple */
4020         /* of the algorithms block size */
4021         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4022         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4023                                 ciphertext_pad_len);
4024         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4025         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4026
4027         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4028
4029         /* Create KASUMI operation */
4030         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4031                                 tdata->cipher_iv.len,
4032                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4033                                 tdata->validCipherOffsetInBits.len);
4034         if (retval < 0)
4035                 return retval;
4036
4037         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4038                                                 ut_params->op);
4039         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4040
4041         ut_params->obuf = ut_params->op->sym->m_dst;
4042         if (ut_params->obuf)
4043                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4044         else
4045                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4046
4047         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4048
4049         const uint8_t *reference_plaintext = tdata->plaintext.data +
4050                                 (tdata->validCipherOffsetInBits.len >> 3);
4051         /* Validate obuf */
4052         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4053                 plaintext,
4054                 reference_plaintext,
4055                 tdata->validCipherLenInBits.len,
4056                 "KASUMI Plaintext data not as expected");
4057         return 0;
4058 }
4059
4060 static int
4061 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4062 {
4063         struct crypto_testsuite_params *ts_params = &testsuite_params;
4064         struct crypto_unittest_params *ut_params = &unittest_params;
4065
4066         int retval;
4067         uint8_t *ciphertext, *plaintext;
4068         unsigned ciphertext_pad_len;
4069         unsigned ciphertext_len;
4070         struct rte_cryptodev_info dev_info;
4071
4072         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4073         uint64_t feat_flags = dev_info.feature_flags;
4074
4075         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4076                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4077                 printf("Device doesn't support RAW data-path APIs.\n");
4078                 return TEST_SKIPPED;
4079         }
4080
4081         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4082                 return TEST_SKIPPED;
4083
4084         /* Verify the capabilities */
4085         struct rte_cryptodev_sym_capability_idx cap_idx;
4086         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4087         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4088         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4089                         &cap_idx) == NULL)
4090                 return TEST_SKIPPED;
4091
4092         /* Create KASUMI session */
4093         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4094                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4095                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4096                                         tdata->key.data, tdata->key.len,
4097                                         tdata->cipher_iv.len);
4098         if (retval < 0)
4099                 return retval;
4100
4101         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4102
4103         /* Clear mbuf payload */
4104         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4105                rte_pktmbuf_tailroom(ut_params->ibuf));
4106
4107         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4108         /* Append data which is padded to a multiple */
4109         /* of the algorithms block size */
4110         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4111         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4112                                 ciphertext_pad_len);
4113         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4114
4115         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4116
4117         /* Create KASUMI operation */
4118         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4119                         tdata->cipher_iv.len,
4120                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4121                         tdata->validCipherOffsetInBits.len);
4122         if (retval < 0)
4123                 return retval;
4124
4125         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4126                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4127                                 ut_params->op, 1, 0, 1, 0);
4128         else
4129                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4130                                                 ut_params->op);
4131         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4132
4133         ut_params->obuf = ut_params->op->sym->m_dst;
4134         if (ut_params->obuf)
4135                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4136         else
4137                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4138
4139         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4140
4141         const uint8_t *reference_plaintext = tdata->plaintext.data +
4142                                 (tdata->validCipherOffsetInBits.len >> 3);
4143         /* Validate obuf */
4144         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4145                 plaintext,
4146                 reference_plaintext,
4147                 tdata->validCipherLenInBits.len,
4148                 "KASUMI Plaintext data not as expected");
4149         return 0;
4150 }
4151
4152 static int
4153 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4154 {
4155         struct crypto_testsuite_params *ts_params = &testsuite_params;
4156         struct crypto_unittest_params *ut_params = &unittest_params;
4157
4158         int retval;
4159         uint8_t *plaintext, *ciphertext;
4160         unsigned plaintext_pad_len;
4161         unsigned plaintext_len;
4162         struct rte_cryptodev_info dev_info;
4163
4164         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4165         uint64_t feat_flags = dev_info.feature_flags;
4166
4167         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4168                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4169                 printf("Device doesn't support RAW data-path APIs.\n");
4170                 return TEST_SKIPPED;
4171         }
4172
4173         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4174                 return TEST_SKIPPED;
4175
4176         /* Verify the capabilities */
4177         struct rte_cryptodev_sym_capability_idx cap_idx;
4178         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4179         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4180         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4181                         &cap_idx) == NULL)
4182                 return TEST_SKIPPED;
4183
4184         /* Create SNOW 3G session */
4185         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4186                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4187                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4188                                         tdata->key.data, tdata->key.len,
4189                                         tdata->cipher_iv.len);
4190         if (retval < 0)
4191                 return retval;
4192
4193         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4194
4195         /* Clear mbuf payload */
4196         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4197                rte_pktmbuf_tailroom(ut_params->ibuf));
4198
4199         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4200         /* Append data which is padded to a multiple of */
4201         /* the algorithms block size */
4202         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4203         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4204                                 plaintext_pad_len);
4205         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4206
4207         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4208
4209         /* Create SNOW 3G operation */
4210         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4211                                         tdata->cipher_iv.len,
4212                                         tdata->validCipherLenInBits.len,
4213                                         0);
4214         if (retval < 0)
4215                 return retval;
4216
4217         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4218                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4219                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4220         else
4221                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4222                                                 ut_params->op);
4223         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4224
4225         ut_params->obuf = ut_params->op->sym->m_dst;
4226         if (ut_params->obuf)
4227                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4228         else
4229                 ciphertext = plaintext;
4230
4231         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4232
4233         /* Validate obuf */
4234         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4235                 ciphertext,
4236                 tdata->ciphertext.data,
4237                 tdata->validDataLenInBits.len,
4238                 "SNOW 3G Ciphertext data not as expected");
4239         return 0;
4240 }
4241
4242
4243 static int
4244 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4245 {
4246         struct crypto_testsuite_params *ts_params = &testsuite_params;
4247         struct crypto_unittest_params *ut_params = &unittest_params;
4248         uint8_t *plaintext, *ciphertext;
4249
4250         int retval;
4251         unsigned plaintext_pad_len;
4252         unsigned plaintext_len;
4253         struct rte_cryptodev_info dev_info;
4254
4255         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4256         uint64_t feat_flags = dev_info.feature_flags;
4257
4258         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4259                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4260                 printf("Device does not support RAW data-path APIs.\n");
4261                 return -ENOTSUP;
4262         }
4263
4264         /* Verify the capabilities */
4265         struct rte_cryptodev_sym_capability_idx cap_idx;
4266         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4267         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4268         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4269                         &cap_idx) == NULL)
4270                 return TEST_SKIPPED;
4271
4272         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4273                 return TEST_SKIPPED;
4274
4275         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4276                 return TEST_SKIPPED;
4277
4278         /* Create SNOW 3G session */
4279         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4280                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4281                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4282                                         tdata->key.data, tdata->key.len,
4283                                         tdata->cipher_iv.len);
4284         if (retval < 0)
4285                 return retval;
4286
4287         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4288         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4289
4290         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4291                         "Failed to allocate input buffer in mempool");
4292         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4293                         "Failed to allocate output buffer in mempool");
4294
4295         /* Clear mbuf payload */
4296         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4297                rte_pktmbuf_tailroom(ut_params->ibuf));
4298
4299         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4300         /* Append data which is padded to a multiple of */
4301         /* the algorithms block size */
4302         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4303         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4304                                 plaintext_pad_len);
4305         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4306         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4307
4308         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4309
4310         /* Create SNOW 3G operation */
4311         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4312                                         tdata->cipher_iv.len,
4313                                         tdata->validCipherLenInBits.len,
4314                                         0);
4315         if (retval < 0)
4316                 return retval;
4317
4318         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4319                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4320                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4321         else
4322                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4323                                                 ut_params->op);
4324         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4325
4326         ut_params->obuf = ut_params->op->sym->m_dst;
4327         if (ut_params->obuf)
4328                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4329         else
4330                 ciphertext = plaintext;
4331
4332         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4333
4334         /* Validate obuf */
4335         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4336                 ciphertext,
4337                 tdata->ciphertext.data,
4338                 tdata->validDataLenInBits.len,
4339                 "SNOW 3G Ciphertext data not as expected");
4340         return 0;
4341 }
4342
4343 static int
4344 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4345 {
4346         struct crypto_testsuite_params *ts_params = &testsuite_params;
4347         struct crypto_unittest_params *ut_params = &unittest_params;
4348
4349         int retval;
4350         unsigned int plaintext_pad_len;
4351         unsigned int plaintext_len;
4352         uint8_t buffer[10000];
4353         const uint8_t *ciphertext;
4354
4355         struct rte_cryptodev_info dev_info;
4356
4357         /* Verify the capabilities */
4358         struct rte_cryptodev_sym_capability_idx cap_idx;
4359         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4360         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4361         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4362                         &cap_idx) == NULL)
4363                 return TEST_SKIPPED;
4364
4365         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4366                 return TEST_SKIPPED;
4367
4368         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4369                 return TEST_SKIPPED;
4370
4371         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4372
4373         uint64_t feat_flags = dev_info.feature_flags;
4374
4375         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4376                 printf("Device doesn't support out-of-place scatter-gather "
4377                                 "in both input and output mbufs. "
4378                                 "Test Skipped.\n");
4379                 return TEST_SKIPPED;
4380         }
4381
4382         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4383                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4384                 printf("Device does not support RAW data-path APIs.\n");
4385                 return -ENOTSUP;
4386         }
4387
4388         /* Create SNOW 3G session */
4389         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4390                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4391                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4392                                         tdata->key.data, tdata->key.len,
4393                                         tdata->cipher_iv.len);
4394         if (retval < 0)
4395                 return retval;
4396
4397         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4398         /* Append data which is padded to a multiple of */
4399         /* the algorithms block size */
4400         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4401
4402         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4403                         plaintext_pad_len, 10, 0);
4404         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4405                         plaintext_pad_len, 3, 0);
4406
4407         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4408                         "Failed to allocate input buffer in mempool");
4409         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4410                         "Failed to allocate output buffer in mempool");
4411
4412         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4413
4414         /* Create SNOW 3G operation */
4415         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4416                                         tdata->cipher_iv.len,
4417                                         tdata->validCipherLenInBits.len,
4418                                         0);
4419         if (retval < 0)
4420                 return retval;
4421
4422         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4423                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4424                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4425         else
4426                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4427                                                 ut_params->op);
4428         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4429
4430         ut_params->obuf = ut_params->op->sym->m_dst;
4431         if (ut_params->obuf)
4432                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4433                                 plaintext_len, buffer);
4434         else
4435                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4436                                 plaintext_len, buffer);
4437
4438         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4439
4440         /* Validate obuf */
4441         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4442                 ciphertext,
4443                 tdata->ciphertext.data,
4444                 tdata->validDataLenInBits.len,
4445                 "SNOW 3G Ciphertext data not as expected");
4446
4447         return 0;
4448 }
4449
4450 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4451 static void
4452 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4453 {
4454         uint8_t curr_byte, prev_byte;
4455         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4456         uint8_t lower_byte_mask = (1 << offset) - 1;
4457         unsigned i;
4458
4459         prev_byte = buffer[0];
4460         buffer[0] >>= offset;
4461
4462         for (i = 1; i < length_in_bytes; i++) {
4463                 curr_byte = buffer[i];
4464                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4465                                 (curr_byte >> offset);
4466                 prev_byte = curr_byte;
4467         }
4468 }
4469
4470 static int
4471 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4472 {
4473         struct crypto_testsuite_params *ts_params = &testsuite_params;
4474         struct crypto_unittest_params *ut_params = &unittest_params;
4475         uint8_t *plaintext, *ciphertext;
4476         int retval;
4477         uint32_t plaintext_len;
4478         uint32_t plaintext_pad_len;
4479         uint8_t extra_offset = 4;
4480         uint8_t *expected_ciphertext_shifted;
4481         struct rte_cryptodev_info dev_info;
4482
4483         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4484         uint64_t feat_flags = dev_info.feature_flags;
4485
4486         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4487                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4488                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4489                 return TEST_SKIPPED;
4490         }
4491
4492         /* Verify the capabilities */
4493         struct rte_cryptodev_sym_capability_idx cap_idx;
4494         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4495         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4496         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4497                         &cap_idx) == NULL)
4498                 return TEST_SKIPPED;
4499
4500         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4501                 return TEST_SKIPPED;
4502
4503         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4504                 return TEST_SKIPPED;
4505
4506         /* Create SNOW 3G session */
4507         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4508                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4509                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4510                                         tdata->key.data, tdata->key.len,
4511                                         tdata->cipher_iv.len);
4512         if (retval < 0)
4513                 return retval;
4514
4515         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4516         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4517
4518         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4519                         "Failed to allocate input buffer in mempool");
4520         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4521                         "Failed to allocate output buffer in mempool");
4522
4523         /* Clear mbuf payload */
4524         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4525                rte_pktmbuf_tailroom(ut_params->ibuf));
4526
4527         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4528         /*
4529          * Append data which is padded to a
4530          * multiple of the algorithms block size
4531          */
4532         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4533
4534         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4535                                                 plaintext_pad_len);
4536
4537         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4538
4539         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4540         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4541
4542 #ifdef RTE_APP_TEST_DEBUG
4543         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4544 #endif
4545         /* Create SNOW 3G operation */
4546         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4547                                         tdata->cipher_iv.len,
4548                                         tdata->validCipherLenInBits.len,
4549                                         extra_offset);
4550         if (retval < 0)
4551                 return retval;
4552
4553         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4554                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4555                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4556         else
4557                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4558                                                 ut_params->op);
4559         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4560
4561         ut_params->obuf = ut_params->op->sym->m_dst;
4562         if (ut_params->obuf)
4563                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4564         else
4565                 ciphertext = plaintext;
4566
4567 #ifdef RTE_APP_TEST_DEBUG
4568         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4569 #endif
4570
4571         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4572
4573         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4574                         "failed to reserve memory for ciphertext shifted\n");
4575
4576         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4577                         ceil_byte_length(tdata->ciphertext.len));
4578         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4579                         extra_offset);
4580         /* Validate obuf */
4581         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4582                 ciphertext,
4583                 expected_ciphertext_shifted,
4584                 tdata->validDataLenInBits.len,
4585                 extra_offset,
4586                 "SNOW 3G Ciphertext data not as expected");
4587         return 0;
4588 }
4589
4590 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4591 {
4592         struct crypto_testsuite_params *ts_params = &testsuite_params;
4593         struct crypto_unittest_params *ut_params = &unittest_params;
4594
4595         int retval;
4596
4597         uint8_t *plaintext, *ciphertext;
4598         unsigned ciphertext_pad_len;
4599         unsigned ciphertext_len;
4600         struct rte_cryptodev_info dev_info;
4601
4602         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4603         uint64_t feat_flags = dev_info.feature_flags;
4604
4605         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4606                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4607                 printf("Device doesn't support RAW data-path APIs.\n");
4608                 return TEST_SKIPPED;
4609         }
4610
4611         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4612                 return TEST_SKIPPED;
4613
4614         /* Verify the capabilities */
4615         struct rte_cryptodev_sym_capability_idx cap_idx;
4616         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4617         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4618         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4619                         &cap_idx) == NULL)
4620                 return TEST_SKIPPED;
4621
4622         /* Create SNOW 3G session */
4623         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4624                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4625                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4626                                         tdata->key.data, tdata->key.len,
4627                                         tdata->cipher_iv.len);
4628         if (retval < 0)
4629                 return retval;
4630
4631         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4632
4633         /* Clear mbuf payload */
4634         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4635                rte_pktmbuf_tailroom(ut_params->ibuf));
4636
4637         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4638         /* Append data which is padded to a multiple of */
4639         /* the algorithms block size */
4640         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4641         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4642                                 ciphertext_pad_len);
4643         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4644
4645         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4646
4647         /* Create SNOW 3G operation */
4648         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4649                                         tdata->cipher_iv.len,
4650                                         tdata->validCipherLenInBits.len,
4651                                         tdata->cipher.offset_bits);
4652         if (retval < 0)
4653                 return retval;
4654
4655         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4656                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4657                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4658         else
4659                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4660                                                 ut_params->op);
4661         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4662         ut_params->obuf = ut_params->op->sym->m_dst;
4663         if (ut_params->obuf)
4664                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4665         else
4666                 plaintext = ciphertext;
4667
4668         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4669
4670         /* Validate obuf */
4671         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4672                                 tdata->plaintext.data,
4673                                 tdata->validDataLenInBits.len,
4674                                 "SNOW 3G Plaintext data not as expected");
4675         return 0;
4676 }
4677
4678 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4679 {
4680         struct crypto_testsuite_params *ts_params = &testsuite_params;
4681         struct crypto_unittest_params *ut_params = &unittest_params;
4682
4683         int retval;
4684
4685         uint8_t *plaintext, *ciphertext;
4686         unsigned ciphertext_pad_len;
4687         unsigned ciphertext_len;
4688         struct rte_cryptodev_info dev_info;
4689
4690         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4691         uint64_t feat_flags = dev_info.feature_flags;
4692
4693         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4694                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4695                 printf("Device does not support RAW data-path APIs.\n");
4696                 return -ENOTSUP;
4697         }
4698         /* Verify the capabilities */
4699         struct rte_cryptodev_sym_capability_idx cap_idx;
4700         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4701         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4702         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4703                         &cap_idx) == NULL)
4704                 return TEST_SKIPPED;
4705
4706         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4707                 return TEST_SKIPPED;
4708
4709         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4710                 return TEST_SKIPPED;
4711
4712         /* Create SNOW 3G session */
4713         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4714                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4715                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4716                                         tdata->key.data, tdata->key.len,
4717                                         tdata->cipher_iv.len);
4718         if (retval < 0)
4719                 return retval;
4720
4721         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4722         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4723
4724         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4725                         "Failed to allocate input buffer");
4726         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4727                         "Failed to allocate output buffer");
4728
4729         /* Clear mbuf payload */
4730         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4731                rte_pktmbuf_tailroom(ut_params->ibuf));
4732
4733         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4734                        rte_pktmbuf_tailroom(ut_params->obuf));
4735
4736         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4737         /* Append data which is padded to a multiple of */
4738         /* the algorithms block size */
4739         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4740         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4741                                 ciphertext_pad_len);
4742         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4743         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4744
4745         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4746
4747         /* Create SNOW 3G operation */
4748         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4749                                         tdata->cipher_iv.len,
4750                                         tdata->validCipherLenInBits.len,
4751                                         0);
4752         if (retval < 0)
4753                 return retval;
4754
4755         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4756                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4757                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4758         else
4759                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4760                                                 ut_params->op);
4761         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4762         ut_params->obuf = ut_params->op->sym->m_dst;
4763         if (ut_params->obuf)
4764                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4765         else
4766                 plaintext = ciphertext;
4767
4768         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4769
4770         /* Validate obuf */
4771         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4772                                 tdata->plaintext.data,
4773                                 tdata->validDataLenInBits.len,
4774                                 "SNOW 3G Plaintext data not as expected");
4775         return 0;
4776 }
4777
4778 static int
4779 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4780 {
4781         struct crypto_testsuite_params *ts_params = &testsuite_params;
4782         struct crypto_unittest_params *ut_params = &unittest_params;
4783
4784         int retval;
4785
4786         uint8_t *plaintext, *ciphertext;
4787         unsigned int plaintext_pad_len;
4788         unsigned int plaintext_len;
4789
4790         struct rte_cryptodev_info dev_info;
4791         struct rte_cryptodev_sym_capability_idx cap_idx;
4792
4793         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4794         uint64_t feat_flags = dev_info.feature_flags;
4795
4796         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4797                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4798                         (tdata->validDataLenInBits.len % 8 != 0))) {
4799                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4800                 return TEST_SKIPPED;
4801         }
4802
4803         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4804                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4805                 printf("Device doesn't support RAW data-path APIs.\n");
4806                 return TEST_SKIPPED;
4807         }
4808
4809         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4810                 return TEST_SKIPPED;
4811
4812         /* Check if device supports ZUC EEA3 */
4813         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4814         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4815
4816         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4817                         &cap_idx) == NULL)
4818                 return TEST_SKIPPED;
4819
4820         /* Check if device supports ZUC EIA3 */
4821         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4822         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4823
4824         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4825                         &cap_idx) == NULL)
4826                 return TEST_SKIPPED;
4827
4828         /* Create ZUC session */
4829         retval = create_zuc_cipher_auth_encrypt_generate_session(
4830                         ts_params->valid_devs[0],
4831                         tdata);
4832         if (retval != 0)
4833                 return retval;
4834         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4835
4836         /* clear mbuf payload */
4837         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4838                         rte_pktmbuf_tailroom(ut_params->ibuf));
4839
4840         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4841         /* Append data which is padded to a multiple of */
4842         /* the algorithms block size */
4843         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4844         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4845                                 plaintext_pad_len);
4846         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4847
4848         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4849
4850         /* Create ZUC operation */
4851         retval = create_zuc_cipher_hash_generate_operation(tdata);
4852         if (retval < 0)
4853                 return retval;
4854
4855         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4856                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4857                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4858         else
4859                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4860                         ut_params->op);
4861         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4862         ut_params->obuf = ut_params->op->sym->m_src;
4863         if (ut_params->obuf)
4864                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4865         else
4866                 ciphertext = plaintext;
4867
4868         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4869         /* Validate obuf */
4870         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4871                         ciphertext,
4872                         tdata->ciphertext.data,
4873                         tdata->validDataLenInBits.len,
4874                         "ZUC Ciphertext data not as expected");
4875
4876         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4877             + plaintext_pad_len;
4878
4879         /* Validate obuf */
4880         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4881                         ut_params->digest,
4882                         tdata->digest.data,
4883                         4,
4884                         "ZUC Generated auth tag not as expected");
4885         return 0;
4886 }
4887
4888 static int
4889 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4890 {
4891         struct crypto_testsuite_params *ts_params = &testsuite_params;
4892         struct crypto_unittest_params *ut_params = &unittest_params;
4893
4894         int retval;
4895
4896         uint8_t *plaintext, *ciphertext;
4897         unsigned plaintext_pad_len;
4898         unsigned plaintext_len;
4899         struct rte_cryptodev_info dev_info;
4900
4901         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4902         uint64_t feat_flags = dev_info.feature_flags;
4903
4904         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4905                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4906                 printf("Device doesn't support RAW data-path APIs.\n");
4907                 return TEST_SKIPPED;
4908         }
4909
4910         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4911                 return TEST_SKIPPED;
4912
4913         /* Verify the capabilities */
4914         struct rte_cryptodev_sym_capability_idx cap_idx;
4915         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4916         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4917         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4918                         &cap_idx) == NULL)
4919                 return TEST_SKIPPED;
4920         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4921         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4922         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4923                         &cap_idx) == NULL)
4924                 return TEST_SKIPPED;
4925
4926         /* Create SNOW 3G session */
4927         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4928                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4929                         RTE_CRYPTO_AUTH_OP_GENERATE,
4930                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4931                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4932                         tdata->key.data, tdata->key.len,
4933                         tdata->auth_iv.len, tdata->digest.len,
4934                         tdata->cipher_iv.len);
4935         if (retval != 0)
4936                 return retval;
4937         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4938
4939         /* clear mbuf payload */
4940         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4941                         rte_pktmbuf_tailroom(ut_params->ibuf));
4942
4943         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4944         /* Append data which is padded to a multiple of */
4945         /* the algorithms block size */
4946         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4947         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4948                                 plaintext_pad_len);
4949         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4950
4951         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4952
4953         /* Create SNOW 3G operation */
4954         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4955                         tdata->digest.len, tdata->auth_iv.data,
4956                         tdata->auth_iv.len,
4957                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4958                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4959                         tdata->validCipherLenInBits.len,
4960                         0,
4961                         tdata->validAuthLenInBits.len,
4962                         0
4963                         );
4964         if (retval < 0)
4965                 return retval;
4966
4967         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4968                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4969                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4970         else
4971                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4972                         ut_params->op);
4973         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4974         ut_params->obuf = ut_params->op->sym->m_src;
4975         if (ut_params->obuf)
4976                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4977         else
4978                 ciphertext = plaintext;
4979
4980         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4981         /* Validate obuf */
4982         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4983                         ciphertext,
4984                         tdata->ciphertext.data,
4985                         tdata->validDataLenInBits.len,
4986                         "SNOW 3G Ciphertext data not as expected");
4987
4988         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4989             + plaintext_pad_len;
4990
4991         /* Validate obuf */
4992         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4993                         ut_params->digest,
4994                         tdata->digest.data,
4995                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4996                         "SNOW 3G Generated auth tag not as expected");
4997         return 0;
4998 }
4999
5000 static int
5001 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
5002         uint8_t op_mode, uint8_t verify)
5003 {
5004         struct crypto_testsuite_params *ts_params = &testsuite_params;
5005         struct crypto_unittest_params *ut_params = &unittest_params;
5006
5007         int retval;
5008
5009         uint8_t *plaintext = NULL, *ciphertext = NULL;
5010         unsigned int plaintext_pad_len;
5011         unsigned int plaintext_len;
5012         unsigned int ciphertext_pad_len;
5013         unsigned int ciphertext_len;
5014
5015         struct rte_cryptodev_info dev_info;
5016
5017         /* Verify the capabilities */
5018         struct rte_cryptodev_sym_capability_idx cap_idx;
5019         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5020         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5021         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5022                         &cap_idx) == NULL)
5023                 return TEST_SKIPPED;
5024         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5025         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5026         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5027                         &cap_idx) == NULL)
5028                 return TEST_SKIPPED;
5029
5030         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5031                 return TEST_SKIPPED;
5032
5033         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5034
5035         uint64_t feat_flags = dev_info.feature_flags;
5036
5037         if (op_mode == OUT_OF_PLACE) {
5038                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5039                         printf("Device doesn't support digest encrypted.\n");
5040                         return TEST_SKIPPED;
5041                 }
5042                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5043                         return TEST_SKIPPED;
5044         }
5045
5046         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5047                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5048                 printf("Device doesn't support RAW data-path APIs.\n");
5049                 return TEST_SKIPPED;
5050         }
5051
5052         /* Create SNOW 3G session */
5053         retval = create_wireless_algo_auth_cipher_session(
5054                         ts_params->valid_devs[0],
5055                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5056                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5057                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5058                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5059                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5060                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5061                         tdata->key.data, tdata->key.len,
5062                         tdata->auth_iv.len, tdata->digest.len,
5063                         tdata->cipher_iv.len);
5064         if (retval != 0)
5065                 return retval;
5066
5067         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5068         if (op_mode == OUT_OF_PLACE)
5069                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5070
5071         /* clear mbuf payload */
5072         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5073                 rte_pktmbuf_tailroom(ut_params->ibuf));
5074         if (op_mode == OUT_OF_PLACE)
5075                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5076                         rte_pktmbuf_tailroom(ut_params->obuf));
5077
5078         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5079         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5080         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5081         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5082
5083         if (verify) {
5084                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5085                                         ciphertext_pad_len);
5086                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5087                 if (op_mode == OUT_OF_PLACE)
5088                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5089                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5090                         ciphertext_len);
5091         } else {
5092                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5093                                         plaintext_pad_len);
5094                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5095                 if (op_mode == OUT_OF_PLACE)
5096                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5097                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5098         }
5099
5100         /* Create SNOW 3G operation */
5101         retval = create_wireless_algo_auth_cipher_operation(
5102                 tdata->digest.data, tdata->digest.len,
5103                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5104                 tdata->auth_iv.data, tdata->auth_iv.len,
5105                 (tdata->digest.offset_bytes == 0 ?
5106                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5107                         : tdata->digest.offset_bytes),
5108                 tdata->validCipherLenInBits.len,
5109                 tdata->cipher.offset_bits,
5110                 tdata->validAuthLenInBits.len,
5111                 tdata->auth.offset_bits,
5112                 op_mode, 0, verify);
5113
5114         if (retval < 0)
5115                 return retval;
5116
5117         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5118                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5119                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5120         else
5121                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5122                         ut_params->op);
5123
5124         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5125
5126         ut_params->obuf = (op_mode == IN_PLACE ?
5127                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5128
5129         if (verify) {
5130                 if (ut_params->obuf)
5131                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5132                                                         uint8_t *);
5133                 else
5134                         plaintext = ciphertext +
5135                                 (tdata->cipher.offset_bits >> 3);
5136
5137                 debug_hexdump(stdout, "plaintext:", plaintext,
5138                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5139                 debug_hexdump(stdout, "plaintext expected:",
5140                         tdata->plaintext.data,
5141                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5142         } else {
5143                 if (ut_params->obuf)
5144                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5145                                                         uint8_t *);
5146                 else
5147                         ciphertext = plaintext;
5148
5149                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5150                         ciphertext_len);
5151                 debug_hexdump(stdout, "ciphertext expected:",
5152                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5153
5154                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5155                         + (tdata->digest.offset_bytes == 0 ?
5156                 plaintext_pad_len : tdata->digest.offset_bytes);
5157
5158                 debug_hexdump(stdout, "digest:", ut_params->digest,
5159                         tdata->digest.len);
5160                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5161                                 tdata->digest.len);
5162         }
5163
5164         /* Validate obuf */
5165         if (verify) {
5166                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5167                         plaintext,
5168                         tdata->plaintext.data,
5169                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5170                          (tdata->digest.len << 3)),
5171                         tdata->cipher.offset_bits,
5172                         "SNOW 3G Plaintext data not as expected");
5173         } else {
5174                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5175                         ciphertext,
5176                         tdata->ciphertext.data,
5177                         (tdata->validDataLenInBits.len -
5178                          tdata->cipher.offset_bits),
5179                         tdata->cipher.offset_bits,
5180                         "SNOW 3G Ciphertext data not as expected");
5181
5182                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5183                         ut_params->digest,
5184                         tdata->digest.data,
5185                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5186                         "SNOW 3G Generated auth tag not as expected");
5187         }
5188         return 0;
5189 }
5190
5191 static int
5192 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5193         uint8_t op_mode, uint8_t verify)
5194 {
5195         struct crypto_testsuite_params *ts_params = &testsuite_params;
5196         struct crypto_unittest_params *ut_params = &unittest_params;
5197
5198         int retval;
5199
5200         const uint8_t *plaintext = NULL;
5201         const uint8_t *ciphertext = NULL;
5202         const uint8_t *digest = NULL;
5203         unsigned int plaintext_pad_len;
5204         unsigned int plaintext_len;
5205         unsigned int ciphertext_pad_len;
5206         unsigned int ciphertext_len;
5207         uint8_t buffer[10000];
5208         uint8_t digest_buffer[10000];
5209
5210         struct rte_cryptodev_info dev_info;
5211
5212         /* Verify the capabilities */
5213         struct rte_cryptodev_sym_capability_idx cap_idx;
5214         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5215         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5216         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5217                         &cap_idx) == NULL)
5218                 return TEST_SKIPPED;
5219         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5220         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5221         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5222                         &cap_idx) == NULL)
5223                 return TEST_SKIPPED;
5224
5225         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5226                 return TEST_SKIPPED;
5227
5228         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5229
5230         uint64_t feat_flags = dev_info.feature_flags;
5231
5232         if (op_mode == IN_PLACE) {
5233                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5234                         printf("Device doesn't support in-place scatter-gather "
5235                                         "in both input and output mbufs.\n");
5236                         return TEST_SKIPPED;
5237                 }
5238                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5239                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5240                         printf("Device doesn't support RAW data-path APIs.\n");
5241                         return TEST_SKIPPED;
5242                 }
5243         } else {
5244                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5245                         return TEST_SKIPPED;
5246                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5247                         printf("Device doesn't support out-of-place scatter-gather "
5248                                         "in both input and output mbufs.\n");
5249                         return TEST_SKIPPED;
5250                 }
5251                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5252                         printf("Device doesn't support digest encrypted.\n");
5253                         return TEST_SKIPPED;
5254                 }
5255         }
5256
5257         /* Create SNOW 3G session */
5258         retval = create_wireless_algo_auth_cipher_session(
5259                         ts_params->valid_devs[0],
5260                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5261                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5262                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5263                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5264                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5265                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5266                         tdata->key.data, tdata->key.len,
5267                         tdata->auth_iv.len, tdata->digest.len,
5268                         tdata->cipher_iv.len);
5269
5270         if (retval != 0)
5271                 return retval;
5272
5273         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5274         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5275         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5276         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5277
5278         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5279                         plaintext_pad_len, 15, 0);
5280         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5281                         "Failed to allocate input buffer in mempool");
5282
5283         if (op_mode == OUT_OF_PLACE) {
5284                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5285                                 plaintext_pad_len, 15, 0);
5286                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5287                                 "Failed to allocate output buffer in mempool");
5288         }
5289
5290         if (verify) {
5291                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5292                         tdata->ciphertext.data);
5293                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5294                                         ciphertext_len, buffer);
5295                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5296                         ciphertext_len);
5297         } else {
5298                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5299                         tdata->plaintext.data);
5300                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5301                                         plaintext_len, buffer);
5302                 debug_hexdump(stdout, "plaintext:", plaintext,
5303                         plaintext_len);
5304         }
5305         memset(buffer, 0, sizeof(buffer));
5306
5307         /* Create SNOW 3G operation */
5308         retval = create_wireless_algo_auth_cipher_operation(
5309                 tdata->digest.data, tdata->digest.len,
5310                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5311                 tdata->auth_iv.data, tdata->auth_iv.len,
5312                 (tdata->digest.offset_bytes == 0 ?
5313                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5314                         : tdata->digest.offset_bytes),
5315                 tdata->validCipherLenInBits.len,
5316                 tdata->cipher.offset_bits,
5317                 tdata->validAuthLenInBits.len,
5318                 tdata->auth.offset_bits,
5319                 op_mode, 1, verify);
5320
5321         if (retval < 0)
5322                 return retval;
5323
5324         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5325                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5326                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5327         else
5328                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5329                         ut_params->op);
5330
5331         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5332
5333         ut_params->obuf = (op_mode == IN_PLACE ?
5334                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5335
5336         if (verify) {
5337                 if (ut_params->obuf)
5338                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5339                                         plaintext_len, buffer);
5340                 else
5341                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5342                                         plaintext_len, buffer);
5343
5344                 debug_hexdump(stdout, "plaintext:", plaintext,
5345                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5346                 debug_hexdump(stdout, "plaintext expected:",
5347                         tdata->plaintext.data,
5348                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5349         } else {
5350                 if (ut_params->obuf)
5351                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5352                                         ciphertext_len, buffer);
5353                 else
5354                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5355                                         ciphertext_len, buffer);
5356
5357                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5358                         ciphertext_len);
5359                 debug_hexdump(stdout, "ciphertext expected:",
5360                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5361
5362                 if (ut_params->obuf)
5363                         digest = rte_pktmbuf_read(ut_params->obuf,
5364                                 (tdata->digest.offset_bytes == 0 ?
5365                                 plaintext_pad_len : tdata->digest.offset_bytes),
5366                                 tdata->digest.len, digest_buffer);
5367                 else
5368                         digest = rte_pktmbuf_read(ut_params->ibuf,
5369                                 (tdata->digest.offset_bytes == 0 ?
5370                                 plaintext_pad_len : tdata->digest.offset_bytes),
5371                                 tdata->digest.len, digest_buffer);
5372
5373                 debug_hexdump(stdout, "digest:", digest,
5374                         tdata->digest.len);
5375                 debug_hexdump(stdout, "digest expected:",
5376                         tdata->digest.data, tdata->digest.len);
5377         }
5378
5379         /* Validate obuf */
5380         if (verify) {
5381                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5382                         plaintext,
5383                         tdata->plaintext.data,
5384                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5385                          (tdata->digest.len << 3)),
5386                         tdata->cipher.offset_bits,
5387                         "SNOW 3G Plaintext data not as expected");
5388         } else {
5389                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5390                         ciphertext,
5391                         tdata->ciphertext.data,
5392                         (tdata->validDataLenInBits.len -
5393                          tdata->cipher.offset_bits),
5394                         tdata->cipher.offset_bits,
5395                         "SNOW 3G Ciphertext data not as expected");
5396
5397                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5398                         digest,
5399                         tdata->digest.data,
5400                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5401                         "SNOW 3G Generated auth tag not as expected");
5402         }
5403         return 0;
5404 }
5405
5406 static int
5407 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5408         uint8_t op_mode, uint8_t verify)
5409 {
5410         struct crypto_testsuite_params *ts_params = &testsuite_params;
5411         struct crypto_unittest_params *ut_params = &unittest_params;
5412
5413         int retval;
5414
5415         uint8_t *plaintext = NULL, *ciphertext = NULL;
5416         unsigned int plaintext_pad_len;
5417         unsigned int plaintext_len;
5418         unsigned int ciphertext_pad_len;
5419         unsigned int ciphertext_len;
5420
5421         struct rte_cryptodev_info dev_info;
5422
5423         /* Verify the capabilities */
5424         struct rte_cryptodev_sym_capability_idx cap_idx;
5425         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5426         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5427         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5428                         &cap_idx) == NULL)
5429                 return TEST_SKIPPED;
5430         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5431         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5432         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5433                         &cap_idx) == NULL)
5434                 return TEST_SKIPPED;
5435
5436         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5437
5438         uint64_t feat_flags = dev_info.feature_flags;
5439
5440         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5441                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5442                 printf("Device doesn't support RAW data-path APIs.\n");
5443                 return TEST_SKIPPED;
5444         }
5445
5446         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5447                 return TEST_SKIPPED;
5448
5449         if (op_mode == OUT_OF_PLACE) {
5450                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5451                         return TEST_SKIPPED;
5452                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5453                         printf("Device doesn't support digest encrypted.\n");
5454                         return TEST_SKIPPED;
5455                 }
5456         }
5457
5458         /* Create KASUMI session */
5459         retval = create_wireless_algo_auth_cipher_session(
5460                         ts_params->valid_devs[0],
5461                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5462                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5463                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5464                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5465                         RTE_CRYPTO_AUTH_KASUMI_F9,
5466                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5467                         tdata->key.data, tdata->key.len,
5468                         0, tdata->digest.len,
5469                         tdata->cipher_iv.len);
5470
5471         if (retval != 0)
5472                 return retval;
5473
5474         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5475         if (op_mode == OUT_OF_PLACE)
5476                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5477
5478         /* clear mbuf payload */
5479         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5480                 rte_pktmbuf_tailroom(ut_params->ibuf));
5481         if (op_mode == OUT_OF_PLACE)
5482                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5483                         rte_pktmbuf_tailroom(ut_params->obuf));
5484
5485         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5486         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5487         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5488         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5489
5490         if (verify) {
5491                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5492                                         ciphertext_pad_len);
5493                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5494                 if (op_mode == OUT_OF_PLACE)
5495                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5496                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5497                         ciphertext_len);
5498         } else {
5499                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5500                                         plaintext_pad_len);
5501                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5502                 if (op_mode == OUT_OF_PLACE)
5503                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5504                 debug_hexdump(stdout, "plaintext:", plaintext,
5505                         plaintext_len);
5506         }
5507
5508         /* Create KASUMI operation */
5509         retval = create_wireless_algo_auth_cipher_operation(
5510                 tdata->digest.data, tdata->digest.len,
5511                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5512                 NULL, 0,
5513                 (tdata->digest.offset_bytes == 0 ?
5514                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5515                         : tdata->digest.offset_bytes),
5516                 tdata->validCipherLenInBits.len,
5517                 tdata->validCipherOffsetInBits.len,
5518                 tdata->validAuthLenInBits.len,
5519                 0,
5520                 op_mode, 0, verify);
5521
5522         if (retval < 0)
5523                 return retval;
5524
5525         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5526                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5527                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5528         else
5529                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5530                         ut_params->op);
5531
5532         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5533
5534         ut_params->obuf = (op_mode == IN_PLACE ?
5535                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5536
5537
5538         if (verify) {
5539                 if (ut_params->obuf)
5540                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5541                                                         uint8_t *);
5542                 else
5543                         plaintext = ciphertext;
5544
5545                 debug_hexdump(stdout, "plaintext:", plaintext,
5546                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5547                 debug_hexdump(stdout, "plaintext expected:",
5548                         tdata->plaintext.data,
5549                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5550         } else {
5551                 if (ut_params->obuf)
5552                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5553                                                         uint8_t *);
5554                 else
5555                         ciphertext = plaintext;
5556
5557                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5558                         ciphertext_len);
5559                 debug_hexdump(stdout, "ciphertext expected:",
5560                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5561
5562                 ut_params->digest = rte_pktmbuf_mtod(
5563                         ut_params->obuf, uint8_t *) +
5564                         (tdata->digest.offset_bytes == 0 ?
5565                         plaintext_pad_len : tdata->digest.offset_bytes);
5566
5567                 debug_hexdump(stdout, "digest:", ut_params->digest,
5568                         tdata->digest.len);
5569                 debug_hexdump(stdout, "digest expected:",
5570                         tdata->digest.data, tdata->digest.len);
5571         }
5572
5573         /* Validate obuf */
5574         if (verify) {
5575                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5576                         plaintext,
5577                         tdata->plaintext.data,
5578                         tdata->plaintext.len >> 3,
5579                         "KASUMI Plaintext data not as expected");
5580         } else {
5581                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5582                         ciphertext,
5583                         tdata->ciphertext.data,
5584                         tdata->ciphertext.len >> 3,
5585                         "KASUMI Ciphertext data not as expected");
5586
5587                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5588                         ut_params->digest,
5589                         tdata->digest.data,
5590                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5591                         "KASUMI Generated auth tag not as expected");
5592         }
5593         return 0;
5594 }
5595
5596 static int
5597 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5598         uint8_t op_mode, uint8_t verify)
5599 {
5600         struct crypto_testsuite_params *ts_params = &testsuite_params;
5601         struct crypto_unittest_params *ut_params = &unittest_params;
5602
5603         int retval;
5604
5605         const uint8_t *plaintext = NULL;
5606         const uint8_t *ciphertext = NULL;
5607         const uint8_t *digest = NULL;
5608         unsigned int plaintext_pad_len;
5609         unsigned int plaintext_len;
5610         unsigned int ciphertext_pad_len;
5611         unsigned int ciphertext_len;
5612         uint8_t buffer[10000];
5613         uint8_t digest_buffer[10000];
5614
5615         struct rte_cryptodev_info dev_info;
5616
5617         /* Verify the capabilities */
5618         struct rte_cryptodev_sym_capability_idx cap_idx;
5619         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5620         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5621         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5622                         &cap_idx) == NULL)
5623                 return TEST_SKIPPED;
5624         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5625         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5626         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5627                         &cap_idx) == NULL)
5628                 return TEST_SKIPPED;
5629
5630         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5631                 return TEST_SKIPPED;
5632
5633         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5634
5635         uint64_t feat_flags = dev_info.feature_flags;
5636
5637         if (op_mode == IN_PLACE) {
5638                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5639                         printf("Device doesn't support in-place scatter-gather "
5640                                         "in both input and output mbufs.\n");
5641                         return TEST_SKIPPED;
5642                 }
5643                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5644                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5645                         printf("Device doesn't support RAW data-path APIs.\n");
5646                         return TEST_SKIPPED;
5647                 }
5648         } else {
5649                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5650                         return TEST_SKIPPED;
5651                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5652                         printf("Device doesn't support out-of-place scatter-gather "
5653                                         "in both input and output mbufs.\n");
5654                         return TEST_SKIPPED;
5655                 }
5656                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5657                         printf("Device doesn't support digest encrypted.\n");
5658                         return TEST_SKIPPED;
5659                 }
5660         }
5661
5662         /* Create KASUMI session */
5663         retval = create_wireless_algo_auth_cipher_session(
5664                         ts_params->valid_devs[0],
5665                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5666                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5667                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5668                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5669                         RTE_CRYPTO_AUTH_KASUMI_F9,
5670                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5671                         tdata->key.data, tdata->key.len,
5672                         0, tdata->digest.len,
5673                         tdata->cipher_iv.len);
5674
5675         if (retval != 0)
5676                 return retval;
5677
5678         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5679         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5680         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5681         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5682
5683         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5684                         plaintext_pad_len, 15, 0);
5685         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5686                         "Failed to allocate input buffer in mempool");
5687
5688         if (op_mode == OUT_OF_PLACE) {
5689                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5690                                 plaintext_pad_len, 15, 0);
5691                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5692                                 "Failed to allocate output buffer in mempool");
5693         }
5694
5695         if (verify) {
5696                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5697                         tdata->ciphertext.data);
5698                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5699                                         ciphertext_len, buffer);
5700                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5701                         ciphertext_len);
5702         } else {
5703                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5704                         tdata->plaintext.data);
5705                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5706                                         plaintext_len, buffer);
5707                 debug_hexdump(stdout, "plaintext:", plaintext,
5708                         plaintext_len);
5709         }
5710         memset(buffer, 0, sizeof(buffer));
5711
5712         /* Create KASUMI operation */
5713         retval = create_wireless_algo_auth_cipher_operation(
5714                 tdata->digest.data, tdata->digest.len,
5715                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5716                 NULL, 0,
5717                 (tdata->digest.offset_bytes == 0 ?
5718                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5719                         : tdata->digest.offset_bytes),
5720                 tdata->validCipherLenInBits.len,
5721                 tdata->validCipherOffsetInBits.len,
5722                 tdata->validAuthLenInBits.len,
5723                 0,
5724                 op_mode, 1, verify);
5725
5726         if (retval < 0)
5727                 return retval;
5728
5729         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5730                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5731                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5732         else
5733                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5734                         ut_params->op);
5735
5736         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5737
5738         ut_params->obuf = (op_mode == IN_PLACE ?
5739                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5740
5741         if (verify) {
5742                 if (ut_params->obuf)
5743                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5744                                         plaintext_len, buffer);
5745                 else
5746                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5747                                         plaintext_len, buffer);
5748
5749                 debug_hexdump(stdout, "plaintext:", plaintext,
5750                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5751                 debug_hexdump(stdout, "plaintext expected:",
5752                         tdata->plaintext.data,
5753                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5754         } else {
5755                 if (ut_params->obuf)
5756                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5757                                         ciphertext_len, buffer);
5758                 else
5759                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5760                                         ciphertext_len, buffer);
5761
5762                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5763                         ciphertext_len);
5764                 debug_hexdump(stdout, "ciphertext expected:",
5765                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5766
5767                 if (ut_params->obuf)
5768                         digest = rte_pktmbuf_read(ut_params->obuf,
5769                                 (tdata->digest.offset_bytes == 0 ?
5770                                 plaintext_pad_len : tdata->digest.offset_bytes),
5771                                 tdata->digest.len, digest_buffer);
5772                 else
5773                         digest = rte_pktmbuf_read(ut_params->ibuf,
5774                                 (tdata->digest.offset_bytes == 0 ?
5775                                 plaintext_pad_len : tdata->digest.offset_bytes),
5776                                 tdata->digest.len, digest_buffer);
5777
5778                 debug_hexdump(stdout, "digest:", digest,
5779                         tdata->digest.len);
5780                 debug_hexdump(stdout, "digest expected:",
5781                         tdata->digest.data, tdata->digest.len);
5782         }
5783
5784         /* Validate obuf */
5785         if (verify) {
5786                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5787                         plaintext,
5788                         tdata->plaintext.data,
5789                         tdata->plaintext.len >> 3,
5790                         "KASUMI Plaintext data not as expected");
5791         } else {
5792                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5793                         ciphertext,
5794                         tdata->ciphertext.data,
5795                         tdata->validDataLenInBits.len,
5796                         "KASUMI Ciphertext data not as expected");
5797
5798                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5799                         digest,
5800                         tdata->digest.data,
5801                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5802                         "KASUMI Generated auth tag not as expected");
5803         }
5804         return 0;
5805 }
5806
5807 static int
5808 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5809 {
5810         struct crypto_testsuite_params *ts_params = &testsuite_params;
5811         struct crypto_unittest_params *ut_params = &unittest_params;
5812
5813         int retval;
5814
5815         uint8_t *plaintext, *ciphertext;
5816         unsigned plaintext_pad_len;
5817         unsigned plaintext_len;
5818         struct rte_cryptodev_info dev_info;
5819
5820         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5821         uint64_t feat_flags = dev_info.feature_flags;
5822
5823         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5824                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5825                 printf("Device doesn't support RAW data-path APIs.\n");
5826                 return TEST_SKIPPED;
5827         }
5828
5829         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5830                 return TEST_SKIPPED;
5831
5832         /* Verify the capabilities */
5833         struct rte_cryptodev_sym_capability_idx cap_idx;
5834         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5835         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5836         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5837                         &cap_idx) == NULL)
5838                 return TEST_SKIPPED;
5839         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5840         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5841         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5842                         &cap_idx) == NULL)
5843                 return TEST_SKIPPED;
5844
5845         /* Create KASUMI session */
5846         retval = create_wireless_algo_cipher_auth_session(
5847                         ts_params->valid_devs[0],
5848                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5849                         RTE_CRYPTO_AUTH_OP_GENERATE,
5850                         RTE_CRYPTO_AUTH_KASUMI_F9,
5851                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5852                         tdata->key.data, tdata->key.len,
5853                         0, tdata->digest.len,
5854                         tdata->cipher_iv.len);
5855         if (retval != 0)
5856                 return retval;
5857
5858         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5859
5860         /* clear mbuf payload */
5861         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5862                         rte_pktmbuf_tailroom(ut_params->ibuf));
5863
5864         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5865         /* Append data which is padded to a multiple of */
5866         /* the algorithms block size */
5867         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5868         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5869                                 plaintext_pad_len);
5870         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5871
5872         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5873
5874         /* Create KASUMI operation */
5875         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5876                                 tdata->digest.len, NULL, 0,
5877                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5878                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5879                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5880                                 tdata->validCipherOffsetInBits.len,
5881                                 tdata->validAuthLenInBits.len,
5882                                 0
5883                                 );
5884         if (retval < 0)
5885                 return retval;
5886
5887         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5888                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5889                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5890         else
5891                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5892                         ut_params->op);
5893         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5894
5895         if (ut_params->op->sym->m_dst)
5896                 ut_params->obuf = ut_params->op->sym->m_dst;
5897         else
5898                 ut_params->obuf = ut_params->op->sym->m_src;
5899
5900         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5901                                 tdata->validCipherOffsetInBits.len >> 3);
5902
5903         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5904                         + plaintext_pad_len;
5905
5906         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5907                                 (tdata->validCipherOffsetInBits.len >> 3);
5908         /* Validate obuf */
5909         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5910                 ciphertext,
5911                 reference_ciphertext,
5912                 tdata->validCipherLenInBits.len,
5913                 "KASUMI Ciphertext data not as expected");
5914
5915         /* Validate obuf */
5916         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5917                 ut_params->digest,
5918                 tdata->digest.data,
5919                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5920                 "KASUMI Generated auth tag not as expected");
5921         return 0;
5922 }
5923
5924 static int
5925 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5926                         const enum rte_crypto_cipher_algorithm cipher_algo,
5927                         const uint16_t key_size, const uint16_t iv_size)
5928 {
5929         struct rte_cryptodev_sym_capability_idx cap_idx;
5930         const struct rte_cryptodev_symmetric_capability *cap;
5931
5932         /* Check if device supports the algorithm */
5933         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5934         cap_idx.algo.cipher = cipher_algo;
5935
5936         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5937                         &cap_idx);
5938
5939         if (cap == NULL)
5940                 return -1;
5941
5942         /* Check if device supports key size and IV size */
5943         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5944                         iv_size) < 0) {
5945                 return -1;
5946         }
5947
5948         return 0;
5949 }
5950
5951 static int
5952 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5953                         const enum rte_crypto_auth_algorithm auth_algo,
5954                         const uint16_t key_size, const uint16_t iv_size,
5955                         const uint16_t tag_size)
5956 {
5957         struct rte_cryptodev_sym_capability_idx cap_idx;
5958         const struct rte_cryptodev_symmetric_capability *cap;
5959
5960         /* Check if device supports the algorithm */
5961         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5962         cap_idx.algo.auth = auth_algo;
5963
5964         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5965                         &cap_idx);
5966
5967         if (cap == NULL)
5968                 return -1;
5969
5970         /* Check if device supports key size and IV size */
5971         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5972                         tag_size, iv_size) < 0) {
5973                 return -1;
5974         }
5975
5976         return 0;
5977 }
5978
5979 static int
5980 test_zuc_encryption(const struct wireless_test_data *tdata)
5981 {
5982         struct crypto_testsuite_params *ts_params = &testsuite_params;
5983         struct crypto_unittest_params *ut_params = &unittest_params;
5984
5985         int retval;
5986         uint8_t *plaintext, *ciphertext;
5987         unsigned plaintext_pad_len;
5988         unsigned plaintext_len;
5989         struct rte_cryptodev_info dev_info;
5990
5991         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5992         uint64_t feat_flags = dev_info.feature_flags;
5993
5994         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5995                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5996                 printf("Device doesn't support RAW data-path APIs.\n");
5997                 return TEST_SKIPPED;
5998         }
5999
6000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6001                 return TEST_SKIPPED;
6002
6003         /* Check if device supports ZUC EEA3 */
6004         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6005                         tdata->key.len, tdata->cipher_iv.len) < 0)
6006                 return TEST_SKIPPED;
6007
6008         /* Create ZUC session */
6009         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6010                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6011                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6012                                         tdata->key.data, tdata->key.len,
6013                                         tdata->cipher_iv.len);
6014         if (retval != 0)
6015                 return retval;
6016
6017         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6018
6019         /* Clear mbuf payload */
6020         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6021                rte_pktmbuf_tailroom(ut_params->ibuf));
6022
6023         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6024         /* Append data which is padded to a multiple */
6025         /* of the algorithms block size */
6026         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6027         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6028                                 plaintext_pad_len);
6029         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6030
6031         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6032
6033         /* Create ZUC operation */
6034         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6035                                         tdata->cipher_iv.len,
6036                                         tdata->plaintext.len,
6037                                         0);
6038         if (retval < 0)
6039                 return retval;
6040
6041         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6042                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6043                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6044         else
6045                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6046                                                 ut_params->op);
6047         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6048
6049         ut_params->obuf = ut_params->op->sym->m_dst;
6050         if (ut_params->obuf)
6051                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6052         else
6053                 ciphertext = plaintext;
6054
6055         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6056
6057         /* Validate obuf */
6058         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6059                 ciphertext,
6060                 tdata->ciphertext.data,
6061                 tdata->validCipherLenInBits.len,
6062                 "ZUC Ciphertext data not as expected");
6063         return 0;
6064 }
6065
6066 static int
6067 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6068 {
6069         struct crypto_testsuite_params *ts_params = &testsuite_params;
6070         struct crypto_unittest_params *ut_params = &unittest_params;
6071
6072         int retval;
6073
6074         unsigned int plaintext_pad_len;
6075         unsigned int plaintext_len;
6076         const uint8_t *ciphertext;
6077         uint8_t ciphertext_buffer[2048];
6078         struct rte_cryptodev_info dev_info;
6079
6080         /* Check if device supports ZUC EEA3 */
6081         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6082                         tdata->key.len, tdata->cipher_iv.len) < 0)
6083                 return TEST_SKIPPED;
6084
6085         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6086                 return TEST_SKIPPED;
6087
6088         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6089
6090         uint64_t feat_flags = dev_info.feature_flags;
6091
6092         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6093                 printf("Device doesn't support in-place scatter-gather. "
6094                                 "Test Skipped.\n");
6095                 return TEST_SKIPPED;
6096         }
6097
6098         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6099                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6100                 printf("Device doesn't support RAW data-path APIs.\n");
6101                 return TEST_SKIPPED;
6102         }
6103
6104         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6105
6106         /* Append data which is padded to a multiple */
6107         /* of the algorithms block size */
6108         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6109
6110         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6111                         plaintext_pad_len, 10, 0);
6112
6113         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6114                         tdata->plaintext.data);
6115
6116         /* Create ZUC session */
6117         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6118                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6119                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6120                         tdata->key.data, tdata->key.len,
6121                         tdata->cipher_iv.len);
6122         if (retval < 0)
6123                 return retval;
6124
6125         /* Clear mbuf payload */
6126
6127         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6128
6129         /* Create ZUC operation */
6130         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6131                         tdata->cipher_iv.len, tdata->plaintext.len,
6132                         0);
6133         if (retval < 0)
6134                 return retval;
6135
6136         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6137                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6138                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6139         else
6140                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6141                                                 ut_params->op);
6142         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6143
6144         ut_params->obuf = ut_params->op->sym->m_dst;
6145         if (ut_params->obuf)
6146                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6147                         0, plaintext_len, ciphertext_buffer);
6148         else
6149                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6150                         0, plaintext_len, ciphertext_buffer);
6151
6152         /* Validate obuf */
6153         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6154
6155         /* Validate obuf */
6156         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6157                 ciphertext,
6158                 tdata->ciphertext.data,
6159                 tdata->validCipherLenInBits.len,
6160                 "ZUC Ciphertext data not as expected");
6161
6162         return 0;
6163 }
6164
6165 static int
6166 test_zuc_authentication(const struct wireless_test_data *tdata)
6167 {
6168         struct crypto_testsuite_params *ts_params = &testsuite_params;
6169         struct crypto_unittest_params *ut_params = &unittest_params;
6170
6171         int retval;
6172         unsigned plaintext_pad_len;
6173         unsigned plaintext_len;
6174         uint8_t *plaintext;
6175
6176         struct rte_cryptodev_info dev_info;
6177
6178         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6179         uint64_t feat_flags = dev_info.feature_flags;
6180
6181         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6182                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6183                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6184                 return TEST_SKIPPED;
6185         }
6186
6187         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6188                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6189                 printf("Device doesn't support RAW data-path APIs.\n");
6190                 return TEST_SKIPPED;
6191         }
6192
6193         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6194                 return TEST_SKIPPED;
6195
6196         /* Check if device supports ZUC EIA3 */
6197         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6198                         tdata->key.len, tdata->auth_iv.len,
6199                         tdata->digest.len) < 0)
6200                 return TEST_SKIPPED;
6201
6202         /* Create ZUC session */
6203         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6204                         tdata->key.data, tdata->key.len,
6205                         tdata->auth_iv.len, tdata->digest.len,
6206                         RTE_CRYPTO_AUTH_OP_GENERATE,
6207                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6208         if (retval != 0)
6209                 return retval;
6210
6211         /* alloc mbuf and set payload */
6212         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6213
6214         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6215         rte_pktmbuf_tailroom(ut_params->ibuf));
6216
6217         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6218         /* Append data which is padded to a multiple of */
6219         /* the algorithms block size */
6220         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6221         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6222                                 plaintext_pad_len);
6223         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6224
6225         /* Create ZUC operation */
6226         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6227                         tdata->auth_iv.data, tdata->auth_iv.len,
6228                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6229                         tdata->validAuthLenInBits.len,
6230                         0);
6231         if (retval < 0)
6232                 return retval;
6233
6234         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6235                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6236                                 ut_params->op, 0, 1, 1, 0);
6237         else
6238                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6239                                 ut_params->op);
6240         ut_params->obuf = ut_params->op->sym->m_src;
6241         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6242         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6243                         + plaintext_pad_len;
6244
6245         /* Validate obuf */
6246         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6247         ut_params->digest,
6248         tdata->digest.data,
6249         tdata->digest.len,
6250         "ZUC Generated auth tag not as expected");
6251
6252         return 0;
6253 }
6254
6255 static int
6256 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6257         uint8_t op_mode, uint8_t verify)
6258 {
6259         struct crypto_testsuite_params *ts_params = &testsuite_params;
6260         struct crypto_unittest_params *ut_params = &unittest_params;
6261
6262         int retval;
6263
6264         uint8_t *plaintext = NULL, *ciphertext = NULL;
6265         unsigned int plaintext_pad_len;
6266         unsigned int plaintext_len;
6267         unsigned int ciphertext_pad_len;
6268         unsigned int ciphertext_len;
6269
6270         struct rte_cryptodev_info dev_info;
6271
6272         /* Check if device supports ZUC EEA3 */
6273         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6274                         tdata->key.len, tdata->cipher_iv.len) < 0)
6275                 return TEST_SKIPPED;
6276
6277         /* Check if device supports ZUC EIA3 */
6278         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6279                         tdata->key.len, tdata->auth_iv.len,
6280                         tdata->digest.len) < 0)
6281                 return TEST_SKIPPED;
6282
6283         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6284
6285         uint64_t feat_flags = dev_info.feature_flags;
6286
6287         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6288                 printf("Device doesn't support digest encrypted.\n");
6289                 return TEST_SKIPPED;
6290         }
6291         if (op_mode == IN_PLACE) {
6292                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6293                         printf("Device doesn't support in-place scatter-gather "
6294                                         "in both input and output mbufs.\n");
6295                         return TEST_SKIPPED;
6296                 }
6297
6298                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6299                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6300                         printf("Device doesn't support RAW data-path APIs.\n");
6301                         return TEST_SKIPPED;
6302                 }
6303         } else {
6304                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6305                         return TEST_SKIPPED;
6306                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6307                         printf("Device doesn't support out-of-place scatter-gather "
6308                                         "in both input and output mbufs.\n");
6309                         return TEST_SKIPPED;
6310                 }
6311         }
6312
6313         /* Create ZUC session */
6314         retval = create_wireless_algo_auth_cipher_session(
6315                         ts_params->valid_devs[0],
6316                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6317                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6318                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6319                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6320                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6321                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6322                         tdata->key.data, tdata->key.len,
6323                         tdata->auth_iv.len, tdata->digest.len,
6324                         tdata->cipher_iv.len);
6325
6326         if (retval != 0)
6327                 return retval;
6328
6329         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6330         if (op_mode == OUT_OF_PLACE)
6331                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6332
6333         /* clear mbuf payload */
6334         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6335                 rte_pktmbuf_tailroom(ut_params->ibuf));
6336         if (op_mode == OUT_OF_PLACE)
6337                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6338                         rte_pktmbuf_tailroom(ut_params->obuf));
6339
6340         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6341         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6342         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6343         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6344
6345         if (verify) {
6346                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6347                                         ciphertext_pad_len);
6348                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6349                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6350                         ciphertext_len);
6351         } else {
6352                 /* make sure enough space to cover partial digest verify case */
6353                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6354                                         ciphertext_pad_len);
6355                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6356                 debug_hexdump(stdout, "plaintext:", plaintext,
6357                         plaintext_len);
6358         }
6359
6360         if (op_mode == OUT_OF_PLACE)
6361                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6362
6363         /* Create ZUC operation */
6364         retval = create_wireless_algo_auth_cipher_operation(
6365                 tdata->digest.data, tdata->digest.len,
6366                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6367                 tdata->auth_iv.data, tdata->auth_iv.len,
6368                 (tdata->digest.offset_bytes == 0 ?
6369                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6370                         : tdata->digest.offset_bytes),
6371                 tdata->validCipherLenInBits.len,
6372                 tdata->validCipherOffsetInBits.len,
6373                 tdata->validAuthLenInBits.len,
6374                 0,
6375                 op_mode, 0, verify);
6376
6377         if (retval < 0)
6378                 return retval;
6379
6380         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6381                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6382                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6383         else
6384                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6385                         ut_params->op);
6386
6387         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6388
6389         ut_params->obuf = (op_mode == IN_PLACE ?
6390                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6391
6392
6393         if (verify) {
6394                 if (ut_params->obuf)
6395                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6396                                                         uint8_t *);
6397                 else
6398                         plaintext = ciphertext;
6399
6400                 debug_hexdump(stdout, "plaintext:", plaintext,
6401                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6402                 debug_hexdump(stdout, "plaintext expected:",
6403                         tdata->plaintext.data,
6404                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6405         } else {
6406                 if (ut_params->obuf)
6407                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6408                                                         uint8_t *);
6409                 else
6410                         ciphertext = plaintext;
6411
6412                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6413                         ciphertext_len);
6414                 debug_hexdump(stdout, "ciphertext expected:",
6415                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6416
6417                 ut_params->digest = rte_pktmbuf_mtod(
6418                         ut_params->obuf, uint8_t *) +
6419                         (tdata->digest.offset_bytes == 0 ?
6420                         plaintext_pad_len : tdata->digest.offset_bytes);
6421
6422                 debug_hexdump(stdout, "digest:", ut_params->digest,
6423                         tdata->digest.len);
6424                 debug_hexdump(stdout, "digest expected:",
6425                         tdata->digest.data, tdata->digest.len);
6426         }
6427
6428         /* Validate obuf */
6429         if (verify) {
6430                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6431                         plaintext,
6432                         tdata->plaintext.data,
6433                         tdata->plaintext.len >> 3,
6434                         "ZUC Plaintext data not as expected");
6435         } else {
6436                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6437                         ciphertext,
6438                         tdata->ciphertext.data,
6439                         tdata->ciphertext.len >> 3,
6440                         "ZUC Ciphertext data not as expected");
6441
6442                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6443                         ut_params->digest,
6444                         tdata->digest.data,
6445                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6446                         "ZUC Generated auth tag not as expected");
6447         }
6448         return 0;
6449 }
6450
6451 static int
6452 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6453         uint8_t op_mode, uint8_t verify)
6454 {
6455         struct crypto_testsuite_params *ts_params = &testsuite_params;
6456         struct crypto_unittest_params *ut_params = &unittest_params;
6457
6458         int retval;
6459
6460         const uint8_t *plaintext = NULL;
6461         const uint8_t *ciphertext = NULL;
6462         const uint8_t *digest = NULL;
6463         unsigned int plaintext_pad_len;
6464         unsigned int plaintext_len;
6465         unsigned int ciphertext_pad_len;
6466         unsigned int ciphertext_len;
6467         uint8_t buffer[10000];
6468         uint8_t digest_buffer[10000];
6469
6470         struct rte_cryptodev_info dev_info;
6471
6472         /* Check if device supports ZUC EEA3 */
6473         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6474                         tdata->key.len, tdata->cipher_iv.len) < 0)
6475                 return TEST_SKIPPED;
6476
6477         /* Check if device supports ZUC EIA3 */
6478         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6479                         tdata->key.len, tdata->auth_iv.len,
6480                         tdata->digest.len) < 0)
6481                 return TEST_SKIPPED;
6482
6483         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6484
6485         uint64_t feat_flags = dev_info.feature_flags;
6486
6487         if (op_mode == IN_PLACE) {
6488                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6489                         printf("Device doesn't support in-place scatter-gather "
6490                                         "in both input and output mbufs.\n");
6491                         return TEST_SKIPPED;
6492                 }
6493
6494                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6495                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6496                         printf("Device doesn't support RAW data-path APIs.\n");
6497                         return TEST_SKIPPED;
6498                 }
6499         } else {
6500                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6501                         return TEST_SKIPPED;
6502                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6503                         printf("Device doesn't support out-of-place scatter-gather "
6504                                         "in both input and output mbufs.\n");
6505                         return TEST_SKIPPED;
6506                 }
6507                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6508                         printf("Device doesn't support digest encrypted.\n");
6509                         return TEST_SKIPPED;
6510                 }
6511         }
6512
6513         /* Create ZUC session */
6514         retval = create_wireless_algo_auth_cipher_session(
6515                         ts_params->valid_devs[0],
6516                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6517                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6518                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6519                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6520                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6521                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6522                         tdata->key.data, tdata->key.len,
6523                         tdata->auth_iv.len, tdata->digest.len,
6524                         tdata->cipher_iv.len);
6525
6526         if (retval != 0)
6527                 return retval;
6528
6529         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6530         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6531         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6532         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6533
6534         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6535                         plaintext_pad_len, 15, 0);
6536         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6537                         "Failed to allocate input buffer in mempool");
6538
6539         if (op_mode == OUT_OF_PLACE) {
6540                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6541                                 plaintext_pad_len, 15, 0);
6542                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6543                                 "Failed to allocate output buffer in mempool");
6544         }
6545
6546         if (verify) {
6547                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6548                         tdata->ciphertext.data);
6549                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6550                                         ciphertext_len, buffer);
6551                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6552                         ciphertext_len);
6553         } else {
6554                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6555                         tdata->plaintext.data);
6556                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6557                                         plaintext_len, buffer);
6558                 debug_hexdump(stdout, "plaintext:", plaintext,
6559                         plaintext_len);
6560         }
6561         memset(buffer, 0, sizeof(buffer));
6562
6563         /* Create ZUC operation */
6564         retval = create_wireless_algo_auth_cipher_operation(
6565                 tdata->digest.data, tdata->digest.len,
6566                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6567                 NULL, 0,
6568                 (tdata->digest.offset_bytes == 0 ?
6569                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6570                         : tdata->digest.offset_bytes),
6571                 tdata->validCipherLenInBits.len,
6572                 tdata->validCipherOffsetInBits.len,
6573                 tdata->validAuthLenInBits.len,
6574                 0,
6575                 op_mode, 1, verify);
6576
6577         if (retval < 0)
6578                 return retval;
6579
6580         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6581                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6582                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6583         else
6584                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6585                         ut_params->op);
6586
6587         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6588
6589         ut_params->obuf = (op_mode == IN_PLACE ?
6590                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6591
6592         if (verify) {
6593                 if (ut_params->obuf)
6594                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6595                                         plaintext_len, buffer);
6596                 else
6597                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6598                                         plaintext_len, buffer);
6599
6600                 debug_hexdump(stdout, "plaintext:", plaintext,
6601                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6602                 debug_hexdump(stdout, "plaintext expected:",
6603                         tdata->plaintext.data,
6604                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6605         } else {
6606                 if (ut_params->obuf)
6607                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6608                                         ciphertext_len, buffer);
6609                 else
6610                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6611                                         ciphertext_len, buffer);
6612
6613                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6614                         ciphertext_len);
6615                 debug_hexdump(stdout, "ciphertext expected:",
6616                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6617
6618                 if (ut_params->obuf)
6619                         digest = rte_pktmbuf_read(ut_params->obuf,
6620                                 (tdata->digest.offset_bytes == 0 ?
6621                                 plaintext_pad_len : tdata->digest.offset_bytes),
6622                                 tdata->digest.len, digest_buffer);
6623                 else
6624                         digest = rte_pktmbuf_read(ut_params->ibuf,
6625                                 (tdata->digest.offset_bytes == 0 ?
6626                                 plaintext_pad_len : tdata->digest.offset_bytes),
6627                                 tdata->digest.len, digest_buffer);
6628
6629                 debug_hexdump(stdout, "digest:", digest,
6630                         tdata->digest.len);
6631                 debug_hexdump(stdout, "digest expected:",
6632                         tdata->digest.data, tdata->digest.len);
6633         }
6634
6635         /* Validate obuf */
6636         if (verify) {
6637                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6638                         plaintext,
6639                         tdata->plaintext.data,
6640                         tdata->plaintext.len >> 3,
6641                         "ZUC Plaintext data not as expected");
6642         } else {
6643                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6644                         ciphertext,
6645                         tdata->ciphertext.data,
6646                         tdata->validDataLenInBits.len,
6647                         "ZUC Ciphertext data not as expected");
6648
6649                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6650                         digest,
6651                         tdata->digest.data,
6652                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6653                         "ZUC Generated auth tag not as expected");
6654         }
6655         return 0;
6656 }
6657
6658 static int
6659 test_kasumi_encryption_test_case_1(void)
6660 {
6661         return test_kasumi_encryption(&kasumi_test_case_1);
6662 }
6663
6664 static int
6665 test_kasumi_encryption_test_case_1_sgl(void)
6666 {
6667         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6668 }
6669
6670 static int
6671 test_kasumi_encryption_test_case_1_oop(void)
6672 {
6673         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6674 }
6675
6676 static int
6677 test_kasumi_encryption_test_case_1_oop_sgl(void)
6678 {
6679         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6680 }
6681
6682 static int
6683 test_kasumi_encryption_test_case_2(void)
6684 {
6685         return test_kasumi_encryption(&kasumi_test_case_2);
6686 }
6687
6688 static int
6689 test_kasumi_encryption_test_case_3(void)
6690 {
6691         return test_kasumi_encryption(&kasumi_test_case_3);
6692 }
6693
6694 static int
6695 test_kasumi_encryption_test_case_4(void)
6696 {
6697         return test_kasumi_encryption(&kasumi_test_case_4);
6698 }
6699
6700 static int
6701 test_kasumi_encryption_test_case_5(void)
6702 {
6703         return test_kasumi_encryption(&kasumi_test_case_5);
6704 }
6705
6706 static int
6707 test_kasumi_decryption_test_case_1(void)
6708 {
6709         return test_kasumi_decryption(&kasumi_test_case_1);
6710 }
6711
6712 static int
6713 test_kasumi_decryption_test_case_1_oop(void)
6714 {
6715         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6716 }
6717
6718 static int
6719 test_kasumi_decryption_test_case_2(void)
6720 {
6721         return test_kasumi_decryption(&kasumi_test_case_2);
6722 }
6723
6724 static int
6725 test_kasumi_decryption_test_case_3(void)
6726 {
6727         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6728         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6729                 return TEST_SKIPPED;
6730         return test_kasumi_decryption(&kasumi_test_case_3);
6731 }
6732
6733 static int
6734 test_kasumi_decryption_test_case_4(void)
6735 {
6736         return test_kasumi_decryption(&kasumi_test_case_4);
6737 }
6738
6739 static int
6740 test_kasumi_decryption_test_case_5(void)
6741 {
6742         return test_kasumi_decryption(&kasumi_test_case_5);
6743 }
6744 static int
6745 test_snow3g_encryption_test_case_1(void)
6746 {
6747         return test_snow3g_encryption(&snow3g_test_case_1);
6748 }
6749
6750 static int
6751 test_snow3g_encryption_test_case_1_oop(void)
6752 {
6753         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6754 }
6755
6756 static int
6757 test_snow3g_encryption_test_case_1_oop_sgl(void)
6758 {
6759         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6760 }
6761
6762
6763 static int
6764 test_snow3g_encryption_test_case_1_offset_oop(void)
6765 {
6766         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6767 }
6768
6769 static int
6770 test_snow3g_encryption_test_case_2(void)
6771 {
6772         return test_snow3g_encryption(&snow3g_test_case_2);
6773 }
6774
6775 static int
6776 test_snow3g_encryption_test_case_3(void)
6777 {
6778         return test_snow3g_encryption(&snow3g_test_case_3);
6779 }
6780
6781 static int
6782 test_snow3g_encryption_test_case_4(void)
6783 {
6784         return test_snow3g_encryption(&snow3g_test_case_4);
6785 }
6786
6787 static int
6788 test_snow3g_encryption_test_case_5(void)
6789 {
6790         return test_snow3g_encryption(&snow3g_test_case_5);
6791 }
6792
6793 static int
6794 test_snow3g_decryption_test_case_1(void)
6795 {
6796         return test_snow3g_decryption(&snow3g_test_case_1);
6797 }
6798
6799 static int
6800 test_snow3g_decryption_test_case_1_oop(void)
6801 {
6802         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6803 }
6804
6805 static int
6806 test_snow3g_decryption_test_case_2(void)
6807 {
6808         return test_snow3g_decryption(&snow3g_test_case_2);
6809 }
6810
6811 static int
6812 test_snow3g_decryption_test_case_3(void)
6813 {
6814         return test_snow3g_decryption(&snow3g_test_case_3);
6815 }
6816
6817 static int
6818 test_snow3g_decryption_test_case_4(void)
6819 {
6820         return test_snow3g_decryption(&snow3g_test_case_4);
6821 }
6822
6823 static int
6824 test_snow3g_decryption_test_case_5(void)
6825 {
6826         return test_snow3g_decryption(&snow3g_test_case_5);
6827 }
6828
6829 /*
6830  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6831  * Pattern digest from snow3g_test_data must be allocated as
6832  * 4 last bytes in plaintext.
6833  */
6834 static void
6835 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6836                 struct snow3g_hash_test_data *output)
6837 {
6838         if ((pattern != NULL) && (output != NULL)) {
6839                 output->key.len = pattern->key.len;
6840
6841                 memcpy(output->key.data,
6842                 pattern->key.data, pattern->key.len);
6843
6844                 output->auth_iv.len = pattern->auth_iv.len;
6845
6846                 memcpy(output->auth_iv.data,
6847                 pattern->auth_iv.data, pattern->auth_iv.len);
6848
6849                 output->plaintext.len = pattern->plaintext.len;
6850
6851                 memcpy(output->plaintext.data,
6852                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6853
6854                 output->digest.len = pattern->digest.len;
6855
6856                 memcpy(output->digest.data,
6857                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6858                 pattern->digest.len);
6859
6860                 output->validAuthLenInBits.len =
6861                 pattern->validAuthLenInBits.len;
6862         }
6863 }
6864
6865 /*
6866  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6867  */
6868 static int
6869 test_snow3g_decryption_with_digest_test_case_1(void)
6870 {
6871         struct snow3g_hash_test_data snow3g_hash_data;
6872         struct rte_cryptodev_info dev_info;
6873         struct crypto_testsuite_params *ts_params = &testsuite_params;
6874
6875         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6876         uint64_t feat_flags = dev_info.feature_flags;
6877
6878         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6879                 printf("Device doesn't support encrypted digest operations.\n");
6880                 return TEST_SKIPPED;
6881         }
6882
6883         /*
6884          * Function prepare data for hash verification test case.
6885          * Digest is allocated in 4 last bytes in plaintext, pattern.
6886          */
6887         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6888
6889         return test_snow3g_decryption(&snow3g_test_case_7) &
6890                         test_snow3g_authentication_verify(&snow3g_hash_data);
6891 }
6892
6893 static int
6894 test_snow3g_cipher_auth_test_case_1(void)
6895 {
6896         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6897 }
6898
6899 static int
6900 test_snow3g_auth_cipher_test_case_1(void)
6901 {
6902         return test_snow3g_auth_cipher(
6903                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6904 }
6905
6906 static int
6907 test_snow3g_auth_cipher_test_case_2(void)
6908 {
6909         return test_snow3g_auth_cipher(
6910                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6911 }
6912
6913 static int
6914 test_snow3g_auth_cipher_test_case_2_oop(void)
6915 {
6916         return test_snow3g_auth_cipher(
6917                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6918 }
6919
6920 static int
6921 test_snow3g_auth_cipher_part_digest_enc(void)
6922 {
6923         return test_snow3g_auth_cipher(
6924                 &snow3g_auth_cipher_partial_digest_encryption,
6925                         IN_PLACE, 0);
6926 }
6927
6928 static int
6929 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6930 {
6931         return test_snow3g_auth_cipher(
6932                 &snow3g_auth_cipher_partial_digest_encryption,
6933                         OUT_OF_PLACE, 0);
6934 }
6935
6936 static int
6937 test_snow3g_auth_cipher_test_case_3_sgl(void)
6938 {
6939         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6940         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6941                 return TEST_SKIPPED;
6942         return test_snow3g_auth_cipher_sgl(
6943                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6944 }
6945
6946 static int
6947 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6948 {
6949         return test_snow3g_auth_cipher_sgl(
6950                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6951 }
6952
6953 static int
6954 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6955 {
6956         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6957         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6958                 return TEST_SKIPPED;
6959         return test_snow3g_auth_cipher_sgl(
6960                 &snow3g_auth_cipher_partial_digest_encryption,
6961                         IN_PLACE, 0);
6962 }
6963
6964 static int
6965 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6966 {
6967         return test_snow3g_auth_cipher_sgl(
6968                 &snow3g_auth_cipher_partial_digest_encryption,
6969                         OUT_OF_PLACE, 0);
6970 }
6971
6972 static int
6973 test_snow3g_auth_cipher_verify_test_case_1(void)
6974 {
6975         return test_snow3g_auth_cipher(
6976                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6977 }
6978
6979 static int
6980 test_snow3g_auth_cipher_verify_test_case_2(void)
6981 {
6982         return test_snow3g_auth_cipher(
6983                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6984 }
6985
6986 static int
6987 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6988 {
6989         return test_snow3g_auth_cipher(
6990                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6991 }
6992
6993 static int
6994 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6995 {
6996         return test_snow3g_auth_cipher(
6997                 &snow3g_auth_cipher_partial_digest_encryption,
6998                         IN_PLACE, 1);
6999 }
7000
7001 static int
7002 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
7003 {
7004         return test_snow3g_auth_cipher(
7005                 &snow3g_auth_cipher_partial_digest_encryption,
7006                         OUT_OF_PLACE, 1);
7007 }
7008
7009 static int
7010 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7011 {
7012         return test_snow3g_auth_cipher_sgl(
7013                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7014 }
7015
7016 static int
7017 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7018 {
7019         return test_snow3g_auth_cipher_sgl(
7020                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7021 }
7022
7023 static int
7024 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7025 {
7026         return test_snow3g_auth_cipher_sgl(
7027                 &snow3g_auth_cipher_partial_digest_encryption,
7028                         IN_PLACE, 1);
7029 }
7030
7031 static int
7032 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7033 {
7034         return test_snow3g_auth_cipher_sgl(
7035                 &snow3g_auth_cipher_partial_digest_encryption,
7036                         OUT_OF_PLACE, 1);
7037 }
7038
7039 static int
7040 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7041 {
7042         return test_snow3g_auth_cipher(
7043                 &snow3g_test_case_7, IN_PLACE, 0);
7044 }
7045
7046 static int
7047 test_kasumi_auth_cipher_test_case_1(void)
7048 {
7049         return test_kasumi_auth_cipher(
7050                 &kasumi_test_case_3, IN_PLACE, 0);
7051 }
7052
7053 static int
7054 test_kasumi_auth_cipher_test_case_2(void)
7055 {
7056         return test_kasumi_auth_cipher(
7057                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7058 }
7059
7060 static int
7061 test_kasumi_auth_cipher_test_case_2_oop(void)
7062 {
7063         return test_kasumi_auth_cipher(
7064                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7065 }
7066
7067 static int
7068 test_kasumi_auth_cipher_test_case_2_sgl(void)
7069 {
7070         return test_kasumi_auth_cipher_sgl(
7071                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7072 }
7073
7074 static int
7075 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7076 {
7077         return test_kasumi_auth_cipher_sgl(
7078                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7079 }
7080
7081 static int
7082 test_kasumi_auth_cipher_verify_test_case_1(void)
7083 {
7084         return test_kasumi_auth_cipher(
7085                 &kasumi_test_case_3, IN_PLACE, 1);
7086 }
7087
7088 static int
7089 test_kasumi_auth_cipher_verify_test_case_2(void)
7090 {
7091         return test_kasumi_auth_cipher(
7092                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7093 }
7094
7095 static int
7096 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7097 {
7098         return test_kasumi_auth_cipher(
7099                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7100 }
7101
7102 static int
7103 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7104 {
7105         return test_kasumi_auth_cipher_sgl(
7106                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7107 }
7108
7109 static int
7110 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7111 {
7112         return test_kasumi_auth_cipher_sgl(
7113                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7114 }
7115
7116 static int
7117 test_kasumi_cipher_auth_test_case_1(void)
7118 {
7119         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7120 }
7121
7122 static int
7123 test_zuc_encryption_test_case_1(void)
7124 {
7125         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7126 }
7127
7128 static int
7129 test_zuc_encryption_test_case_2(void)
7130 {
7131         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7132 }
7133
7134 static int
7135 test_zuc_encryption_test_case_3(void)
7136 {
7137         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7138 }
7139
7140 static int
7141 test_zuc_encryption_test_case_4(void)
7142 {
7143         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7144 }
7145
7146 static int
7147 test_zuc_encryption_test_case_5(void)
7148 {
7149         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7150 }
7151
7152 static int
7153 test_zuc_encryption_test_case_6_sgl(void)
7154 {
7155         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7156 }
7157
7158 static int
7159 test_zuc_hash_generate_test_case_1(void)
7160 {
7161         return test_zuc_authentication(&zuc_test_case_auth_1b);
7162 }
7163
7164 static int
7165 test_zuc_hash_generate_test_case_2(void)
7166 {
7167         return test_zuc_authentication(&zuc_test_case_auth_90b);
7168 }
7169
7170 static int
7171 test_zuc_hash_generate_test_case_3(void)
7172 {
7173         return test_zuc_authentication(&zuc_test_case_auth_577b);
7174 }
7175
7176 static int
7177 test_zuc_hash_generate_test_case_4(void)
7178 {
7179         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7180 }
7181
7182 static int
7183 test_zuc_hash_generate_test_case_5(void)
7184 {
7185         return test_zuc_authentication(&zuc_test_auth_5670b);
7186 }
7187
7188 static int
7189 test_zuc_hash_generate_test_case_6(void)
7190 {
7191         return test_zuc_authentication(&zuc_test_case_auth_128b);
7192 }
7193
7194 static int
7195 test_zuc_hash_generate_test_case_7(void)
7196 {
7197         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7198 }
7199
7200 static int
7201 test_zuc_hash_generate_test_case_8(void)
7202 {
7203         return test_zuc_authentication(&zuc_test_case_auth_584b);
7204 }
7205
7206 static int
7207 test_zuc_hash_generate_test_case_9(void)
7208 {
7209         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7210 }
7211
7212 static int
7213 test_zuc_hash_generate_test_case_10(void)
7214 {
7215         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7216 }
7217
7218 static int
7219 test_zuc_hash_generate_test_case_11(void)
7220 {
7221         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7222 }
7223
7224 static int
7225 test_zuc_cipher_auth_test_case_1(void)
7226 {
7227         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7228 }
7229
7230 static int
7231 test_zuc_cipher_auth_test_case_2(void)
7232 {
7233         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7234 }
7235
7236 static int
7237 test_zuc_auth_cipher_test_case_1(void)
7238 {
7239         return test_zuc_auth_cipher(
7240                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7241 }
7242
7243 static int
7244 test_zuc_auth_cipher_test_case_1_oop(void)
7245 {
7246         return test_zuc_auth_cipher(
7247                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7248 }
7249
7250 static int
7251 test_zuc_auth_cipher_test_case_1_sgl(void)
7252 {
7253         return test_zuc_auth_cipher_sgl(
7254                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7255 }
7256
7257 static int
7258 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7259 {
7260         return test_zuc_auth_cipher_sgl(
7261                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7262 }
7263
7264 static int
7265 test_zuc_auth_cipher_verify_test_case_1(void)
7266 {
7267         return test_zuc_auth_cipher(
7268                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7269 }
7270
7271 static int
7272 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7273 {
7274         return test_zuc_auth_cipher(
7275                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7276 }
7277
7278 static int
7279 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7280 {
7281         return test_zuc_auth_cipher_sgl(
7282                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7283 }
7284
7285 static int
7286 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7287 {
7288         return test_zuc_auth_cipher_sgl(
7289                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7290 }
7291
7292 static int
7293 test_zuc256_encryption_test_case_1(void)
7294 {
7295         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7296 }
7297
7298 static int
7299 test_zuc256_encryption_test_case_2(void)
7300 {
7301         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7302 }
7303
7304 static int
7305 test_zuc256_authentication_test_case_1(void)
7306 {
7307         return test_zuc_authentication(&zuc256_test_case_auth_1);
7308 }
7309
7310 static int
7311 test_zuc256_authentication_test_case_2(void)
7312 {
7313         return test_zuc_authentication(&zuc256_test_case_auth_2);
7314 }
7315
7316 static int
7317 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7318 {
7319         uint8_t dev_id = testsuite_params.valid_devs[0];
7320
7321         struct rte_cryptodev_sym_capability_idx cap_idx;
7322
7323         /* Check if device supports particular cipher algorithm */
7324         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7325         cap_idx.algo.cipher = tdata->cipher_algo;
7326         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7327                 return TEST_SKIPPED;
7328
7329         /* Check if device supports particular hash algorithm */
7330         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7331         cap_idx.algo.auth = tdata->auth_algo;
7332         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7333                 return TEST_SKIPPED;
7334
7335         return 0;
7336 }
7337
7338 static int
7339 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7340         uint8_t op_mode, uint8_t verify)
7341 {
7342         struct crypto_testsuite_params *ts_params = &testsuite_params;
7343         struct crypto_unittest_params *ut_params = &unittest_params;
7344
7345         int retval;
7346
7347         uint8_t *plaintext = NULL, *ciphertext = NULL;
7348         unsigned int plaintext_pad_len;
7349         unsigned int plaintext_len;
7350         unsigned int ciphertext_pad_len;
7351         unsigned int ciphertext_len;
7352
7353         struct rte_cryptodev_info dev_info;
7354         struct rte_crypto_op *op;
7355
7356         /* Check if device supports particular algorithms separately */
7357         if (test_mixed_check_if_unsupported(tdata))
7358                 return TEST_SKIPPED;
7359         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7360                 return TEST_SKIPPED;
7361
7362         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7363
7364         uint64_t feat_flags = dev_info.feature_flags;
7365
7366         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7367                 printf("Device doesn't support digest encrypted.\n");
7368                 return TEST_SKIPPED;
7369         }
7370
7371         /* Create the session */
7372         if (verify)
7373                 retval = create_wireless_algo_cipher_auth_session(
7374                                 ts_params->valid_devs[0],
7375                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7376                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7377                                 tdata->auth_algo,
7378                                 tdata->cipher_algo,
7379                                 tdata->auth_key.data, tdata->auth_key.len,
7380                                 tdata->auth_iv.len, tdata->digest_enc.len,
7381                                 tdata->cipher_iv.len);
7382         else
7383                 retval = create_wireless_algo_auth_cipher_session(
7384                                 ts_params->valid_devs[0],
7385                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7386                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7387                                 tdata->auth_algo,
7388                                 tdata->cipher_algo,
7389                                 tdata->auth_key.data, tdata->auth_key.len,
7390                                 tdata->auth_iv.len, tdata->digest_enc.len,
7391                                 tdata->cipher_iv.len);
7392         if (retval != 0)
7393                 return retval;
7394
7395         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7396         if (op_mode == OUT_OF_PLACE)
7397                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7398
7399         /* clear mbuf payload */
7400         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7401                 rte_pktmbuf_tailroom(ut_params->ibuf));
7402         if (op_mode == OUT_OF_PLACE) {
7403
7404                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7405                                 rte_pktmbuf_tailroom(ut_params->obuf));
7406         }
7407
7408         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7409         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7410         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7411         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7412
7413         if (verify) {
7414                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7415                                 ciphertext_pad_len);
7416                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7417                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7418                                 ciphertext_len);
7419         } else {
7420                 /* make sure enough space to cover partial digest verify case */
7421                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7422                                 ciphertext_pad_len);
7423                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7424                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7425         }
7426
7427         if (op_mode == OUT_OF_PLACE)
7428                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7429
7430         /* Create the operation */
7431         retval = create_wireless_algo_auth_cipher_operation(
7432                         tdata->digest_enc.data, tdata->digest_enc.len,
7433                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7434                         tdata->auth_iv.data, tdata->auth_iv.len,
7435                         (tdata->digest_enc.offset == 0 ?
7436                                 plaintext_pad_len
7437                                 : tdata->digest_enc.offset),
7438                         tdata->validCipherLen.len_bits,
7439                         tdata->cipher.offset_bits,
7440                         tdata->validAuthLen.len_bits,
7441                         tdata->auth.offset_bits,
7442                         op_mode, 0, verify);
7443
7444         if (retval < 0)
7445                 return retval;
7446
7447         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7448
7449         /* Check if the op failed because the device doesn't */
7450         /* support this particular combination of algorithms */
7451         if (op == NULL && ut_params->op->status ==
7452                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7453                 printf("Device doesn't support this mixed combination. "
7454                                 "Test Skipped.\n");
7455                 return TEST_SKIPPED;
7456         }
7457         ut_params->op = op;
7458
7459         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7460
7461         ut_params->obuf = (op_mode == IN_PLACE ?
7462                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7463
7464         if (verify) {
7465                 if (ut_params->obuf)
7466                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7467                                                         uint8_t *);
7468                 else
7469                         plaintext = ciphertext +
7470                                         (tdata->cipher.offset_bits >> 3);
7471
7472                 debug_hexdump(stdout, "plaintext:", plaintext,
7473                                 tdata->plaintext.len_bits >> 3);
7474                 debug_hexdump(stdout, "plaintext expected:",
7475                                 tdata->plaintext.data,
7476                                 tdata->plaintext.len_bits >> 3);
7477         } else {
7478                 if (ut_params->obuf)
7479                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7480                                         uint8_t *);
7481                 else
7482                         ciphertext = plaintext;
7483
7484                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7485                                 ciphertext_len);
7486                 debug_hexdump(stdout, "ciphertext expected:",
7487                                 tdata->ciphertext.data,
7488                                 tdata->ciphertext.len_bits >> 3);
7489
7490                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7491                                 + (tdata->digest_enc.offset == 0 ?
7492                 plaintext_pad_len : tdata->digest_enc.offset);
7493
7494                 debug_hexdump(stdout, "digest:", ut_params->digest,
7495                                 tdata->digest_enc.len);
7496                 debug_hexdump(stdout, "digest expected:",
7497                                 tdata->digest_enc.data,
7498                                 tdata->digest_enc.len);
7499         }
7500
7501         if (!verify) {
7502                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7503                                 ut_params->digest,
7504                                 tdata->digest_enc.data,
7505                                 tdata->digest_enc.len,
7506                                 "Generated auth tag not as expected");
7507         }
7508
7509         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7510                 if (verify) {
7511                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7512                                         plaintext,
7513                                         tdata->plaintext.data,
7514                                         tdata->plaintext.len_bits >> 3,
7515                                         "Plaintext data not as expected");
7516                 } else {
7517                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7518                                         ciphertext,
7519                                         tdata->ciphertext.data,
7520                                         tdata->validDataLen.len_bits,
7521                                         "Ciphertext data not as expected");
7522                 }
7523         }
7524
7525         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7526                         "crypto op processing failed");
7527
7528         return 0;
7529 }
7530
7531 static int
7532 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7533         uint8_t op_mode, uint8_t verify)
7534 {
7535         struct crypto_testsuite_params *ts_params = &testsuite_params;
7536         struct crypto_unittest_params *ut_params = &unittest_params;
7537
7538         int retval;
7539
7540         const uint8_t *plaintext = NULL;
7541         const uint8_t *ciphertext = NULL;
7542         const uint8_t *digest = NULL;
7543         unsigned int plaintext_pad_len;
7544         unsigned int plaintext_len;
7545         unsigned int ciphertext_pad_len;
7546         unsigned int ciphertext_len;
7547         uint8_t buffer[10000];
7548         uint8_t digest_buffer[10000];
7549
7550         struct rte_cryptodev_info dev_info;
7551         struct rte_crypto_op *op;
7552
7553         /* Check if device supports particular algorithms */
7554         if (test_mixed_check_if_unsupported(tdata))
7555                 return TEST_SKIPPED;
7556         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7557                 return TEST_SKIPPED;
7558
7559         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7560
7561         uint64_t feat_flags = dev_info.feature_flags;
7562
7563         if (op_mode == IN_PLACE) {
7564                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7565                         printf("Device doesn't support in-place scatter-gather "
7566                                         "in both input and output mbufs.\n");
7567                         return TEST_SKIPPED;
7568                 }
7569         } else {
7570                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7571                         printf("Device doesn't support out-of-place scatter-gather "
7572                                         "in both input and output mbufs.\n");
7573                         return TEST_SKIPPED;
7574                 }
7575                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7576                         printf("Device doesn't support digest encrypted.\n");
7577                         return TEST_SKIPPED;
7578                 }
7579         }
7580
7581         /* Create the session */
7582         if (verify)
7583                 retval = create_wireless_algo_cipher_auth_session(
7584                                 ts_params->valid_devs[0],
7585                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7586                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7587                                 tdata->auth_algo,
7588                                 tdata->cipher_algo,
7589                                 tdata->auth_key.data, tdata->auth_key.len,
7590                                 tdata->auth_iv.len, tdata->digest_enc.len,
7591                                 tdata->cipher_iv.len);
7592         else
7593                 retval = create_wireless_algo_auth_cipher_session(
7594                                 ts_params->valid_devs[0],
7595                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7596                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7597                                 tdata->auth_algo,
7598                                 tdata->cipher_algo,
7599                                 tdata->auth_key.data, tdata->auth_key.len,
7600                                 tdata->auth_iv.len, tdata->digest_enc.len,
7601                                 tdata->cipher_iv.len);
7602         if (retval != 0)
7603                 return retval;
7604
7605         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7606         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7607         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7608         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7609
7610         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7611                         ciphertext_pad_len, 15, 0);
7612         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7613                         "Failed to allocate input buffer in mempool");
7614
7615         if (op_mode == OUT_OF_PLACE) {
7616                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7617                                 plaintext_pad_len, 15, 0);
7618                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7619                                 "Failed to allocate output buffer in mempool");
7620         }
7621
7622         if (verify) {
7623                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7624                         tdata->ciphertext.data);
7625                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7626                                         ciphertext_len, buffer);
7627                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7628                         ciphertext_len);
7629         } else {
7630                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7631                         tdata->plaintext.data);
7632                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7633                                         plaintext_len, buffer);
7634                 debug_hexdump(stdout, "plaintext:", plaintext,
7635                         plaintext_len);
7636         }
7637         memset(buffer, 0, sizeof(buffer));
7638
7639         /* Create the operation */
7640         retval = create_wireless_algo_auth_cipher_operation(
7641                         tdata->digest_enc.data, tdata->digest_enc.len,
7642                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7643                         tdata->auth_iv.data, tdata->auth_iv.len,
7644                         (tdata->digest_enc.offset == 0 ?
7645                                 plaintext_pad_len
7646                                 : tdata->digest_enc.offset),
7647                         tdata->validCipherLen.len_bits,
7648                         tdata->cipher.offset_bits,
7649                         tdata->validAuthLen.len_bits,
7650                         tdata->auth.offset_bits,
7651                         op_mode, 1, verify);
7652
7653         if (retval < 0)
7654                 return retval;
7655
7656         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7657
7658         /* Check if the op failed because the device doesn't */
7659         /* support this particular combination of algorithms */
7660         if (op == NULL && ut_params->op->status ==
7661                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7662                 printf("Device doesn't support this mixed combination. "
7663                                 "Test Skipped.\n");
7664                 return TEST_SKIPPED;
7665         }
7666         ut_params->op = op;
7667
7668         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7669
7670         ut_params->obuf = (op_mode == IN_PLACE ?
7671                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7672
7673         if (verify) {
7674                 if (ut_params->obuf)
7675                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7676                                         plaintext_len, buffer);
7677                 else
7678                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7679                                         plaintext_len, buffer);
7680
7681                 debug_hexdump(stdout, "plaintext:", plaintext,
7682                                 (tdata->plaintext.len_bits >> 3) -
7683                                 tdata->digest_enc.len);
7684                 debug_hexdump(stdout, "plaintext expected:",
7685                                 tdata->plaintext.data,
7686                                 (tdata->plaintext.len_bits >> 3) -
7687                                 tdata->digest_enc.len);
7688         } else {
7689                 if (ut_params->obuf)
7690                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7691                                         ciphertext_len, buffer);
7692                 else
7693                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7694                                         ciphertext_len, buffer);
7695
7696                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7697                         ciphertext_len);
7698                 debug_hexdump(stdout, "ciphertext expected:",
7699                         tdata->ciphertext.data,
7700                         tdata->ciphertext.len_bits >> 3);
7701
7702                 if (ut_params->obuf)
7703                         digest = rte_pktmbuf_read(ut_params->obuf,
7704                                         (tdata->digest_enc.offset == 0 ?
7705                                                 plaintext_pad_len :
7706                                                 tdata->digest_enc.offset),
7707                                         tdata->digest_enc.len, digest_buffer);
7708                 else
7709                         digest = rte_pktmbuf_read(ut_params->ibuf,
7710                                         (tdata->digest_enc.offset == 0 ?
7711                                                 plaintext_pad_len :
7712                                                 tdata->digest_enc.offset),
7713                                         tdata->digest_enc.len, digest_buffer);
7714
7715                 debug_hexdump(stdout, "digest:", digest,
7716                                 tdata->digest_enc.len);
7717                 debug_hexdump(stdout, "digest expected:",
7718                                 tdata->digest_enc.data, tdata->digest_enc.len);
7719         }
7720
7721         if (!verify) {
7722                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7723                                 digest,
7724                                 tdata->digest_enc.data,
7725                                 tdata->digest_enc.len,
7726                                 "Generated auth tag not as expected");
7727         }
7728
7729         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7730                 if (verify) {
7731                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7732                                         plaintext,
7733                                         tdata->plaintext.data,
7734                                         tdata->plaintext.len_bits >> 3,
7735                                         "Plaintext data not as expected");
7736                 } else {
7737                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7738                                         ciphertext,
7739                                         tdata->ciphertext.data,
7740                                         tdata->validDataLen.len_bits,
7741                                         "Ciphertext data not as expected");
7742                 }
7743         }
7744
7745         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7746                         "crypto op processing failed");
7747
7748         return 0;
7749 }
7750
7751 /** AUTH AES CMAC + CIPHER AES CTR */
7752
7753 static int
7754 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7755 {
7756         return test_mixed_auth_cipher(
7757                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7758 }
7759
7760 static int
7761 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7762 {
7763         return test_mixed_auth_cipher(
7764                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7765 }
7766
7767 static int
7768 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7769 {
7770         return test_mixed_auth_cipher_sgl(
7771                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7772 }
7773
7774 static int
7775 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7776 {
7777         return test_mixed_auth_cipher_sgl(
7778                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7779 }
7780
7781 static int
7782 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7783 {
7784         return test_mixed_auth_cipher(
7785                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7786 }
7787
7788 static int
7789 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7790 {
7791         return test_mixed_auth_cipher(
7792                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7793 }
7794
7795 static int
7796 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7797 {
7798         return test_mixed_auth_cipher_sgl(
7799                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7800 }
7801
7802 static int
7803 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7804 {
7805         return test_mixed_auth_cipher_sgl(
7806                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7807 }
7808
7809 /** MIXED AUTH + CIPHER */
7810
7811 static int
7812 test_auth_zuc_cipher_snow_test_case_1(void)
7813 {
7814         return test_mixed_auth_cipher(
7815                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7816 }
7817
7818 static int
7819 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7820 {
7821         return test_mixed_auth_cipher(
7822                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7823 }
7824
7825 static int
7826 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7827 {
7828         return test_mixed_auth_cipher(
7829                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7830 }
7831
7832 static int
7833 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7834 {
7835         return test_mixed_auth_cipher(
7836                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7837 }
7838
7839 static int
7840 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7841 {
7842         return test_mixed_auth_cipher(
7843                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7844 }
7845
7846 static int
7847 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7848 {
7849         return test_mixed_auth_cipher(
7850                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7851 }
7852
7853 static int
7854 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7855 {
7856         return test_mixed_auth_cipher(
7857                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7858 }
7859
7860 static int
7861 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7862 {
7863         return test_mixed_auth_cipher(
7864                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7865 }
7866
7867 static int
7868 test_auth_snow_cipher_zuc_test_case_1(void)
7869 {
7870         return test_mixed_auth_cipher(
7871                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7872 }
7873
7874 static int
7875 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7876 {
7877         return test_mixed_auth_cipher(
7878                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7879 }
7880
7881 static int
7882 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7883 {
7884         return test_mixed_auth_cipher(
7885                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7886 }
7887
7888 static int
7889 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7890 {
7891         return test_mixed_auth_cipher(
7892                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7893 }
7894
7895 static int
7896 test_auth_null_cipher_snow_test_case_1(void)
7897 {
7898         return test_mixed_auth_cipher(
7899                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7900 }
7901
7902 static int
7903 test_verify_auth_null_cipher_snow_test_case_1(void)
7904 {
7905         return test_mixed_auth_cipher(
7906                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7907 }
7908
7909 static int
7910 test_auth_null_cipher_zuc_test_case_1(void)
7911 {
7912         return test_mixed_auth_cipher(
7913                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7914 }
7915
7916 static int
7917 test_verify_auth_null_cipher_zuc_test_case_1(void)
7918 {
7919         return test_mixed_auth_cipher(
7920                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7921 }
7922
7923 static int
7924 test_auth_snow_cipher_null_test_case_1(void)
7925 {
7926         return test_mixed_auth_cipher(
7927                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7928 }
7929
7930 static int
7931 test_verify_auth_snow_cipher_null_test_case_1(void)
7932 {
7933         return test_mixed_auth_cipher(
7934                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7935 }
7936
7937 static int
7938 test_auth_zuc_cipher_null_test_case_1(void)
7939 {
7940         return test_mixed_auth_cipher(
7941                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7942 }
7943
7944 static int
7945 test_verify_auth_zuc_cipher_null_test_case_1(void)
7946 {
7947         return test_mixed_auth_cipher(
7948                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7949 }
7950
7951 static int
7952 test_auth_null_cipher_aes_ctr_test_case_1(void)
7953 {
7954         return test_mixed_auth_cipher(
7955                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7956 }
7957
7958 static int
7959 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7960 {
7961         return test_mixed_auth_cipher(
7962                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7963 }
7964
7965 static int
7966 test_auth_aes_cmac_cipher_null_test_case_1(void)
7967 {
7968         return test_mixed_auth_cipher(
7969                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7970 }
7971
7972 static int
7973 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7974 {
7975         return test_mixed_auth_cipher(
7976                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7977 }
7978
7979 /* ***** AEAD algorithm Tests ***** */
7980
7981 static int
7982 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7983                 enum rte_crypto_aead_operation op,
7984                 const uint8_t *key, const uint8_t key_len,
7985                 const uint16_t aad_len, const uint8_t auth_len,
7986                 uint8_t iv_len)
7987 {
7988         uint8_t aead_key[key_len];
7989         int status;
7990
7991         struct crypto_testsuite_params *ts_params = &testsuite_params;
7992         struct crypto_unittest_params *ut_params = &unittest_params;
7993
7994         memcpy(aead_key, key, key_len);
7995
7996         /* Setup AEAD Parameters */
7997         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7998         ut_params->aead_xform.next = NULL;
7999         ut_params->aead_xform.aead.algo = algo;
8000         ut_params->aead_xform.aead.op = op;
8001         ut_params->aead_xform.aead.key.data = aead_key;
8002         ut_params->aead_xform.aead.key.length = key_len;
8003         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8004         ut_params->aead_xform.aead.iv.length = iv_len;
8005         ut_params->aead_xform.aead.digest_length = auth_len;
8006         ut_params->aead_xform.aead.aad_length = aad_len;
8007
8008         debug_hexdump(stdout, "key:", key, key_len);
8009
8010         /* Create Crypto session*/
8011         ut_params->sess = rte_cryptodev_sym_session_create(
8012                         ts_params->session_mpool);
8013         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8014
8015         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8016                         &ut_params->aead_xform,
8017                         ts_params->session_priv_mpool);
8018
8019         return status;
8020 }
8021
8022 static int
8023 create_aead_xform(struct rte_crypto_op *op,
8024                 enum rte_crypto_aead_algorithm algo,
8025                 enum rte_crypto_aead_operation aead_op,
8026                 uint8_t *key, const uint8_t key_len,
8027                 const uint8_t aad_len, const uint8_t auth_len,
8028                 uint8_t iv_len)
8029 {
8030         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8031                         "failed to allocate space for crypto transform");
8032
8033         struct rte_crypto_sym_op *sym_op = op->sym;
8034
8035         /* Setup AEAD Parameters */
8036         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8037         sym_op->xform->next = NULL;
8038         sym_op->xform->aead.algo = algo;
8039         sym_op->xform->aead.op = aead_op;
8040         sym_op->xform->aead.key.data = key;
8041         sym_op->xform->aead.key.length = key_len;
8042         sym_op->xform->aead.iv.offset = IV_OFFSET;
8043         sym_op->xform->aead.iv.length = iv_len;
8044         sym_op->xform->aead.digest_length = auth_len;
8045         sym_op->xform->aead.aad_length = aad_len;
8046
8047         debug_hexdump(stdout, "key:", key, key_len);
8048
8049         return 0;
8050 }
8051
8052 static int
8053 create_aead_operation(enum rte_crypto_aead_operation op,
8054                 const struct aead_test_data *tdata)
8055 {
8056         struct crypto_testsuite_params *ts_params = &testsuite_params;
8057         struct crypto_unittest_params *ut_params = &unittest_params;
8058
8059         uint8_t *plaintext, *ciphertext;
8060         unsigned int aad_pad_len, plaintext_pad_len;
8061
8062         /* Generate Crypto op data structure */
8063         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8064                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8065         TEST_ASSERT_NOT_NULL(ut_params->op,
8066                         "Failed to allocate symmetric crypto operation struct");
8067
8068         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8069
8070         /* Append aad data */
8071         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8072                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8073                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8074                                 aad_pad_len);
8075                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8076                                 "no room to append aad");
8077
8078                 sym_op->aead.aad.phys_addr =
8079                                 rte_pktmbuf_iova(ut_params->ibuf);
8080                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8081                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8082                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8083                         tdata->aad.len);
8084
8085                 /* Append IV at the end of the crypto operation*/
8086                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8087                                 uint8_t *, IV_OFFSET);
8088
8089                 /* Copy IV 1 byte after the IV pointer, according to the API */
8090                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8091                 debug_hexdump(stdout, "iv:", iv_ptr,
8092                         tdata->iv.len);
8093         } else {
8094                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8095                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8096                                 aad_pad_len);
8097                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8098                                 "no room to append aad");
8099
8100                 sym_op->aead.aad.phys_addr =
8101                                 rte_pktmbuf_iova(ut_params->ibuf);
8102                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8103                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8104                         tdata->aad.len);
8105
8106                 /* Append IV at the end of the crypto operation*/
8107                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8108                                 uint8_t *, IV_OFFSET);
8109
8110                 if (tdata->iv.len == 0) {
8111                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8112                         debug_hexdump(stdout, "iv:", iv_ptr,
8113                                 AES_GCM_J0_LENGTH);
8114                 } else {
8115                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8116                         debug_hexdump(stdout, "iv:", iv_ptr,
8117                                 tdata->iv.len);
8118                 }
8119         }
8120
8121         /* Append plaintext/ciphertext */
8122         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8123                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8124                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8125                                 plaintext_pad_len);
8126                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8127
8128                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8129                 debug_hexdump(stdout, "plaintext:", plaintext,
8130                                 tdata->plaintext.len);
8131
8132                 if (ut_params->obuf) {
8133                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8134                                         ut_params->obuf,
8135                                         plaintext_pad_len + aad_pad_len);
8136                         TEST_ASSERT_NOT_NULL(ciphertext,
8137                                         "no room to append ciphertext");
8138
8139                         memset(ciphertext + aad_pad_len, 0,
8140                                         tdata->ciphertext.len);
8141                 }
8142         } else {
8143                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8144                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8145                                 plaintext_pad_len);
8146                 TEST_ASSERT_NOT_NULL(ciphertext,
8147                                 "no room to append ciphertext");
8148
8149                 memcpy(ciphertext, tdata->ciphertext.data,
8150                                 tdata->ciphertext.len);
8151                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8152                                 tdata->ciphertext.len);
8153
8154                 if (ut_params->obuf) {
8155                         plaintext = (uint8_t *)rte_pktmbuf_append(
8156                                         ut_params->obuf,
8157                                         plaintext_pad_len + aad_pad_len);
8158                         TEST_ASSERT_NOT_NULL(plaintext,
8159                                         "no room to append plaintext");
8160
8161                         memset(plaintext + aad_pad_len, 0,
8162                                         tdata->plaintext.len);
8163                 }
8164         }
8165
8166         /* Append digest data */
8167         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8168                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8169                                 ut_params->obuf ? ut_params->obuf :
8170                                                 ut_params->ibuf,
8171                                                 tdata->auth_tag.len);
8172                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8173                                 "no room to append digest");
8174                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8175                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8176                                 ut_params->obuf ? ut_params->obuf :
8177                                                 ut_params->ibuf,
8178                                                 plaintext_pad_len +
8179                                                 aad_pad_len);
8180         } else {
8181                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8182                                 ut_params->ibuf, tdata->auth_tag.len);
8183                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8184                                 "no room to append digest");
8185                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8186                                 ut_params->ibuf,
8187                                 plaintext_pad_len + aad_pad_len);
8188
8189                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8190                         tdata->auth_tag.len);
8191                 debug_hexdump(stdout, "digest:",
8192                         sym_op->aead.digest.data,
8193                         tdata->auth_tag.len);
8194         }
8195
8196         sym_op->aead.data.length = tdata->plaintext.len;
8197         sym_op->aead.data.offset = aad_pad_len;
8198
8199         return 0;
8200 }
8201
8202 static int
8203 test_authenticated_encryption(const struct aead_test_data *tdata)
8204 {
8205         struct crypto_testsuite_params *ts_params = &testsuite_params;
8206         struct crypto_unittest_params *ut_params = &unittest_params;
8207
8208         int retval;
8209         uint8_t *ciphertext, *auth_tag;
8210         uint16_t plaintext_pad_len;
8211         uint32_t i;
8212         struct rte_cryptodev_info dev_info;
8213
8214         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8215         uint64_t feat_flags = dev_info.feature_flags;
8216
8217         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8218                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8219                 printf("Device doesn't support RAW data-path APIs.\n");
8220                 return TEST_SKIPPED;
8221         }
8222
8223         /* Verify the capabilities */
8224         struct rte_cryptodev_sym_capability_idx cap_idx;
8225         const struct rte_cryptodev_symmetric_capability *capability;
8226         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8227         cap_idx.algo.aead = tdata->algo;
8228         capability = rte_cryptodev_sym_capability_get(
8229                         ts_params->valid_devs[0], &cap_idx);
8230         if (capability == NULL)
8231                 return TEST_SKIPPED;
8232         if (rte_cryptodev_sym_capability_check_aead(
8233                         capability, tdata->key.len, tdata->auth_tag.len,
8234                         tdata->aad.len, tdata->iv.len))
8235                 return TEST_SKIPPED;
8236
8237         /* Create AEAD session */
8238         retval = create_aead_session(ts_params->valid_devs[0],
8239                         tdata->algo,
8240                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8241                         tdata->key.data, tdata->key.len,
8242                         tdata->aad.len, tdata->auth_tag.len,
8243                         tdata->iv.len);
8244         if (retval < 0)
8245                 return retval;
8246
8247         if (tdata->aad.len > MBUF_SIZE) {
8248                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8249                 /* Populate full size of add data */
8250                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8251                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8252         } else
8253                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8254
8255         /* clear mbuf payload */
8256         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8257                         rte_pktmbuf_tailroom(ut_params->ibuf));
8258
8259         /* Create AEAD operation */
8260         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8261         if (retval < 0)
8262                 return retval;
8263
8264         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8265
8266         ut_params->op->sym->m_src = ut_params->ibuf;
8267
8268         /* Process crypto operation */
8269         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8270                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8271         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8272                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8273                                 ut_params->op, 0, 0, 0, 0);
8274         else
8275                 TEST_ASSERT_NOT_NULL(
8276                         process_crypto_request(ts_params->valid_devs[0],
8277                         ut_params->op), "failed to process sym crypto op");
8278
8279         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8280                         "crypto op processing failed");
8281
8282         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8283
8284         if (ut_params->op->sym->m_dst) {
8285                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8286                                 uint8_t *);
8287                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8288                                 uint8_t *, plaintext_pad_len);
8289         } else {
8290                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8291                                 uint8_t *,
8292                                 ut_params->op->sym->cipher.data.offset);
8293                 auth_tag = ciphertext + plaintext_pad_len;
8294         }
8295
8296         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8297         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8298
8299         /* Validate obuf */
8300         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8301                         ciphertext,
8302                         tdata->ciphertext.data,
8303                         tdata->ciphertext.len,
8304                         "Ciphertext data not as expected");
8305
8306         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8307                         auth_tag,
8308                         tdata->auth_tag.data,
8309                         tdata->auth_tag.len,
8310                         "Generated auth tag not as expected");
8311
8312         return 0;
8313
8314 }
8315
8316 #ifdef RTE_LIB_SECURITY
8317 static int
8318 security_proto_supported(enum rte_security_session_action_type action,
8319         enum rte_security_session_protocol proto)
8320 {
8321         struct crypto_testsuite_params *ts_params = &testsuite_params;
8322
8323         const struct rte_security_capability *capabilities;
8324         const struct rte_security_capability *capability;
8325         uint16_t i = 0;
8326
8327         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8328                                 rte_cryptodev_get_sec_ctx(
8329                                 ts_params->valid_devs[0]);
8330
8331
8332         capabilities = rte_security_capabilities_get(ctx);
8333
8334         if (capabilities == NULL)
8335                 return -ENOTSUP;
8336
8337         while ((capability = &capabilities[i++])->action !=
8338                         RTE_SECURITY_ACTION_TYPE_NONE) {
8339                 if (capability->action == action &&
8340                                 capability->protocol == proto)
8341                         return 0;
8342         }
8343
8344         return -ENOTSUP;
8345 }
8346
8347 /* Basic algorithm run function for async inplace mode.
8348  * Creates a session from input parameters and runs one operation
8349  * on input_vec. Checks the output of the crypto operation against
8350  * output_vec.
8351  */
8352 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8353                            enum rte_crypto_auth_operation opa,
8354                            const uint8_t *input_vec, unsigned int input_vec_len,
8355                            const uint8_t *output_vec,
8356                            unsigned int output_vec_len,
8357                            enum rte_crypto_cipher_algorithm cipher_alg,
8358                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8359                            enum rte_crypto_auth_algorithm auth_alg,
8360                            const uint8_t *auth_key, uint32_t auth_key_len,
8361                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8362                            uint8_t packet_direction, uint8_t sn_size,
8363                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8364 {
8365         struct crypto_testsuite_params *ts_params = &testsuite_params;
8366         struct crypto_unittest_params *ut_params = &unittest_params;
8367         uint8_t *plaintext;
8368         int ret = TEST_SUCCESS;
8369         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8370                                 rte_cryptodev_get_sec_ctx(
8371                                 ts_params->valid_devs[0]);
8372
8373         /* Verify the capabilities */
8374         struct rte_security_capability_idx sec_cap_idx;
8375
8376         sec_cap_idx.action = ut_params->type;
8377         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8378         sec_cap_idx.pdcp.domain = domain;
8379         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8380                 return TEST_SKIPPED;
8381
8382         /* Generate test mbuf data */
8383         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8384
8385         /* clear mbuf payload */
8386         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8387                         rte_pktmbuf_tailroom(ut_params->ibuf));
8388
8389         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8390                                                   input_vec_len);
8391         memcpy(plaintext, input_vec, input_vec_len);
8392
8393         /* Out of place support */
8394         if (oop) {
8395                 /*
8396                  * For out-op-place we need to alloc another mbuf
8397                  */
8398                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8399                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8400         }
8401
8402         /* Setup Cipher Parameters */
8403         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8404         ut_params->cipher_xform.cipher.algo = cipher_alg;
8405         ut_params->cipher_xform.cipher.op = opc;
8406         ut_params->cipher_xform.cipher.key.data = cipher_key;
8407         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8408         ut_params->cipher_xform.cipher.iv.length =
8409                                 packet_direction ? 4 : 0;
8410         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8411
8412         /* Setup HMAC Parameters if ICV header is required */
8413         if (auth_alg != 0) {
8414                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8415                 ut_params->auth_xform.next = NULL;
8416                 ut_params->auth_xform.auth.algo = auth_alg;
8417                 ut_params->auth_xform.auth.op = opa;
8418                 ut_params->auth_xform.auth.key.data = auth_key;
8419                 ut_params->auth_xform.auth.key.length = auth_key_len;
8420
8421                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8422         } else {
8423                 ut_params->cipher_xform.next = NULL;
8424         }
8425
8426         struct rte_security_session_conf sess_conf = {
8427                 .action_type = ut_params->type,
8428                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8429                 {.pdcp = {
8430                         .bearer = bearer,
8431                         .domain = domain,
8432                         .pkt_dir = packet_direction,
8433                         .sn_size = sn_size,
8434                         .hfn = packet_direction ? 0 : hfn,
8435                         /**
8436                          * hfn can be set as pdcp_test_hfn[i]
8437                          * if hfn_ovrd is not set. Here, PDCP
8438                          * packet direction is just used to
8439                          * run half of the cases with session
8440                          * HFN and other half with per packet
8441                          * HFN.
8442                          */
8443                         .hfn_threshold = hfn_threshold,
8444                         .hfn_ovrd = packet_direction ? 1 : 0,
8445                         .sdap_enabled = sdap,
8446                 } },
8447                 .crypto_xform = &ut_params->cipher_xform
8448         };
8449
8450         /* Create security session */
8451         ut_params->sec_session = rte_security_session_create(ctx,
8452                                 &sess_conf, ts_params->session_mpool,
8453                                 ts_params->session_priv_mpool);
8454
8455         if (!ut_params->sec_session) {
8456                 printf("TestCase %s()-%d line %d failed %s: ",
8457                         __func__, i, __LINE__, "Failed to allocate session");
8458                 ret = TEST_FAILED;
8459                 goto on_err;
8460         }
8461
8462         /* Generate crypto op data structure */
8463         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8464                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8465         if (!ut_params->op) {
8466                 printf("TestCase %s()-%d line %d failed %s: ",
8467                         __func__, i, __LINE__,
8468                         "Failed to allocate symmetric crypto operation struct");
8469                 ret = TEST_FAILED;
8470                 goto on_err;
8471         }
8472
8473         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8474                                         uint32_t *, IV_OFFSET);
8475         *per_pkt_hfn = packet_direction ? hfn : 0;
8476
8477         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8478
8479         /* set crypto operation source mbuf */
8480         ut_params->op->sym->m_src = ut_params->ibuf;
8481         if (oop)
8482                 ut_params->op->sym->m_dst = ut_params->obuf;
8483
8484         /* Process crypto operation */
8485         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8486                 == NULL) {
8487                 printf("TestCase %s()-%d line %d failed %s: ",
8488                         __func__, i, __LINE__,
8489                         "failed to process sym crypto op");
8490                 ret = TEST_FAILED;
8491                 goto on_err;
8492         }
8493
8494         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8495                 printf("TestCase %s()-%d line %d failed %s: ",
8496                         __func__, i, __LINE__, "crypto op processing failed");
8497                 ret = TEST_FAILED;
8498                 goto on_err;
8499         }
8500
8501         /* Validate obuf */
8502         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8503                         uint8_t *);
8504         if (oop) {
8505                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8506                                 uint8_t *);
8507         }
8508
8509         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8510                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8511                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8512                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8513                 ret = TEST_FAILED;
8514                 goto on_err;
8515         }
8516
8517 on_err:
8518         rte_crypto_op_free(ut_params->op);
8519         ut_params->op = NULL;
8520
8521         if (ut_params->sec_session)
8522                 rte_security_session_destroy(ctx, ut_params->sec_session);
8523         ut_params->sec_session = NULL;
8524
8525         rte_pktmbuf_free(ut_params->ibuf);
8526         ut_params->ibuf = NULL;
8527         if (oop) {
8528                 rte_pktmbuf_free(ut_params->obuf);
8529                 ut_params->obuf = NULL;
8530         }
8531
8532         return ret;
8533 }
8534
8535 static int
8536 test_pdcp_proto_SGL(int i, int oop,
8537         enum rte_crypto_cipher_operation opc,
8538         enum rte_crypto_auth_operation opa,
8539         uint8_t *input_vec,
8540         unsigned int input_vec_len,
8541         uint8_t *output_vec,
8542         unsigned int output_vec_len,
8543         uint32_t fragsz,
8544         uint32_t fragsz_oop)
8545 {
8546         struct crypto_testsuite_params *ts_params = &testsuite_params;
8547         struct crypto_unittest_params *ut_params = &unittest_params;
8548         uint8_t *plaintext;
8549         struct rte_mbuf *buf, *buf_oop = NULL;
8550         int ret = TEST_SUCCESS;
8551         int to_trn = 0;
8552         int to_trn_tbl[16];
8553         int segs = 1;
8554         unsigned int trn_data = 0;
8555         struct rte_cryptodev_info dev_info;
8556         uint64_t feat_flags;
8557         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8558                                 rte_cryptodev_get_sec_ctx(
8559                                 ts_params->valid_devs[0]);
8560         struct rte_mbuf *temp_mbuf;
8561
8562         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8563         feat_flags = dev_info.feature_flags;
8564
8565         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8566                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8567                 printf("Device does not support RAW data-path APIs.\n");
8568                 return -ENOTSUP;
8569         }
8570         /* Verify the capabilities */
8571         struct rte_security_capability_idx sec_cap_idx;
8572
8573         sec_cap_idx.action = ut_params->type;
8574         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8575         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8576         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8577                 return TEST_SKIPPED;
8578
8579         if (fragsz > input_vec_len)
8580                 fragsz = input_vec_len;
8581
8582         uint16_t plaintext_len = fragsz;
8583         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8584
8585         if (fragsz_oop > output_vec_len)
8586                 frag_size_oop = output_vec_len;
8587
8588         int ecx = 0;
8589         if (input_vec_len % fragsz != 0) {
8590                 if (input_vec_len / fragsz + 1 > 16)
8591                         return 1;
8592         } else if (input_vec_len / fragsz > 16)
8593                 return 1;
8594
8595         /* Out of place support */
8596         if (oop) {
8597                 /*
8598                  * For out-op-place we need to alloc another mbuf
8599                  */
8600                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8601                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8602                 buf_oop = ut_params->obuf;
8603         }
8604
8605         /* Generate test mbuf data */
8606         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8607
8608         /* clear mbuf payload */
8609         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8610                         rte_pktmbuf_tailroom(ut_params->ibuf));
8611
8612         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8613                                                   plaintext_len);
8614         memcpy(plaintext, input_vec, plaintext_len);
8615         trn_data += plaintext_len;
8616
8617         buf = ut_params->ibuf;
8618
8619         /*
8620          * Loop until no more fragments
8621          */
8622
8623         while (trn_data < input_vec_len) {
8624                 ++segs;
8625                 to_trn = (input_vec_len - trn_data < fragsz) ?
8626                                 (input_vec_len - trn_data) : fragsz;
8627
8628                 to_trn_tbl[ecx++] = to_trn;
8629
8630                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8631                 buf = buf->next;
8632
8633                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8634                                 rte_pktmbuf_tailroom(buf));
8635
8636                 /* OOP */
8637                 if (oop && !fragsz_oop) {
8638                         buf_oop->next =
8639                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8640                         buf_oop = buf_oop->next;
8641                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8642                                         0, rte_pktmbuf_tailroom(buf_oop));
8643                         rte_pktmbuf_append(buf_oop, to_trn);
8644                 }
8645
8646                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8647                                 to_trn);
8648
8649                 memcpy(plaintext, input_vec + trn_data, to_trn);
8650                 trn_data += to_trn;
8651         }
8652
8653         ut_params->ibuf->nb_segs = segs;
8654
8655         segs = 1;
8656         if (fragsz_oop && oop) {
8657                 to_trn = 0;
8658                 ecx = 0;
8659
8660                 trn_data = frag_size_oop;
8661                 while (trn_data < output_vec_len) {
8662                         ++segs;
8663                         to_trn =
8664                                 (output_vec_len - trn_data <
8665                                                 frag_size_oop) ?
8666                                 (output_vec_len - trn_data) :
8667                                                 frag_size_oop;
8668
8669                         to_trn_tbl[ecx++] = to_trn;
8670
8671                         buf_oop->next =
8672                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8673                         buf_oop = buf_oop->next;
8674                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8675                                         0, rte_pktmbuf_tailroom(buf_oop));
8676                         rte_pktmbuf_append(buf_oop, to_trn);
8677
8678                         trn_data += to_trn;
8679                 }
8680                 ut_params->obuf->nb_segs = segs;
8681         }
8682
8683         /* Setup Cipher Parameters */
8684         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8685         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8686         ut_params->cipher_xform.cipher.op = opc;
8687         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8688         ut_params->cipher_xform.cipher.key.length =
8689                                         pdcp_test_params[i].cipher_key_len;
8690         ut_params->cipher_xform.cipher.iv.length = 0;
8691
8692         /* Setup HMAC Parameters if ICV header is required */
8693         if (pdcp_test_params[i].auth_alg != 0) {
8694                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8695                 ut_params->auth_xform.next = NULL;
8696                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8697                 ut_params->auth_xform.auth.op = opa;
8698                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8699                 ut_params->auth_xform.auth.key.length =
8700                                         pdcp_test_params[i].auth_key_len;
8701
8702                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8703         } else {
8704                 ut_params->cipher_xform.next = NULL;
8705         }
8706
8707         struct rte_security_session_conf sess_conf = {
8708                 .action_type = ut_params->type,
8709                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8710                 {.pdcp = {
8711                         .bearer = pdcp_test_bearer[i],
8712                         .domain = pdcp_test_params[i].domain,
8713                         .pkt_dir = pdcp_test_packet_direction[i],
8714                         .sn_size = pdcp_test_data_sn_size[i],
8715                         .hfn = pdcp_test_hfn[i],
8716                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8717                         .hfn_ovrd = 0,
8718                 } },
8719                 .crypto_xform = &ut_params->cipher_xform
8720         };
8721
8722         /* Create security session */
8723         ut_params->sec_session = rte_security_session_create(ctx,
8724                                 &sess_conf, ts_params->session_mpool,
8725                                 ts_params->session_priv_mpool);
8726
8727         if (!ut_params->sec_session) {
8728                 printf("TestCase %s()-%d line %d failed %s: ",
8729                         __func__, i, __LINE__, "Failed to allocate session");
8730                 ret = TEST_FAILED;
8731                 goto on_err;
8732         }
8733
8734         /* Generate crypto op data structure */
8735         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8736                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8737         if (!ut_params->op) {
8738                 printf("TestCase %s()-%d line %d failed %s: ",
8739                         __func__, i, __LINE__,
8740                         "Failed to allocate symmetric crypto operation struct");
8741                 ret = TEST_FAILED;
8742                 goto on_err;
8743         }
8744
8745         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8746
8747         /* set crypto operation source mbuf */
8748         ut_params->op->sym->m_src = ut_params->ibuf;
8749         if (oop)
8750                 ut_params->op->sym->m_dst = ut_params->obuf;
8751
8752         /* Process crypto operation */
8753         temp_mbuf = ut_params->op->sym->m_src;
8754         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8755                 /* filling lengths */
8756                 while (temp_mbuf) {
8757                         ut_params->op->sym->cipher.data.length
8758                                 += temp_mbuf->pkt_len;
8759                         ut_params->op->sym->auth.data.length
8760                                 += temp_mbuf->pkt_len;
8761                         temp_mbuf = temp_mbuf->next;
8762                 }
8763                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8764                         ut_params->op, 1, 1, 0, 0);
8765         } else {
8766                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8767                                                         ut_params->op);
8768         }
8769         if (ut_params->op == NULL) {
8770                 printf("TestCase %s()-%d line %d failed %s: ",
8771                         __func__, i, __LINE__,
8772                         "failed to process sym crypto op");
8773                 ret = TEST_FAILED;
8774                 goto on_err;
8775         }
8776
8777         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8778                 printf("TestCase %s()-%d line %d failed %s: ",
8779                         __func__, i, __LINE__, "crypto op processing failed");
8780                 ret = TEST_FAILED;
8781                 goto on_err;
8782         }
8783
8784         /* Validate obuf */
8785         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8786                         uint8_t *);
8787         if (oop) {
8788                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8789                                 uint8_t *);
8790         }
8791         if (fragsz_oop)
8792                 fragsz = frag_size_oop;
8793         if (memcmp(ciphertext, output_vec, fragsz)) {
8794                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8795                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8796                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8797                 ret = TEST_FAILED;
8798                 goto on_err;
8799         }
8800
8801         buf = ut_params->op->sym->m_src->next;
8802         if (oop)
8803                 buf = ut_params->op->sym->m_dst->next;
8804
8805         unsigned int off = fragsz;
8806
8807         ecx = 0;
8808         while (buf) {
8809                 ciphertext = rte_pktmbuf_mtod(buf,
8810                                 uint8_t *);
8811                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8812                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8813                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8814                         rte_hexdump(stdout, "reference", output_vec + off,
8815                                         to_trn_tbl[ecx]);
8816                         ret = TEST_FAILED;
8817                         goto on_err;
8818                 }
8819                 off += to_trn_tbl[ecx++];
8820                 buf = buf->next;
8821         }
8822 on_err:
8823         rte_crypto_op_free(ut_params->op);
8824         ut_params->op = NULL;
8825
8826         if (ut_params->sec_session)
8827                 rte_security_session_destroy(ctx, ut_params->sec_session);
8828         ut_params->sec_session = NULL;
8829
8830         rte_pktmbuf_free(ut_params->ibuf);
8831         ut_params->ibuf = NULL;
8832         if (oop) {
8833                 rte_pktmbuf_free(ut_params->obuf);
8834                 ut_params->obuf = NULL;
8835         }
8836
8837         return ret;
8838 }
8839
8840 int
8841 test_pdcp_proto_cplane_encap(int i)
8842 {
8843         return test_pdcp_proto(
8844                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8845                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8846                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8847                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8848                 pdcp_test_params[i].cipher_key_len,
8849                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8850                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8851                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8852                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8853                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8854 }
8855
8856 int
8857 test_pdcp_proto_uplane_encap(int i)
8858 {
8859         return test_pdcp_proto(
8860                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8861                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8862                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8863                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8864                 pdcp_test_params[i].cipher_key_len,
8865                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8866                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8867                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8868                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8869                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8870 }
8871
8872 int
8873 test_pdcp_proto_uplane_encap_with_int(int i)
8874 {
8875         return test_pdcp_proto(
8876                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8877                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8878                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8879                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8880                 pdcp_test_params[i].cipher_key_len,
8881                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8882                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8883                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8884                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8885                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8886 }
8887
8888 int
8889 test_pdcp_proto_cplane_decap(int i)
8890 {
8891         return test_pdcp_proto(
8892                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8893                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8894                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8895                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8896                 pdcp_test_params[i].cipher_key_len,
8897                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8898                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8899                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8900                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8901                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8902 }
8903
8904 int
8905 test_pdcp_proto_uplane_decap(int i)
8906 {
8907         return test_pdcp_proto(
8908                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8909                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8910                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8911                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8912                 pdcp_test_params[i].cipher_key_len,
8913                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8914                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8915                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8916                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8917                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8918 }
8919
8920 int
8921 test_pdcp_proto_uplane_decap_with_int(int i)
8922 {
8923         return test_pdcp_proto(
8924                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8925                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8926                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8927                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8928                 pdcp_test_params[i].cipher_key_len,
8929                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8930                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8931                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8932                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8933                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8934 }
8935
8936 static int
8937 test_PDCP_PROTO_SGL_in_place_32B(void)
8938 {
8939         /* i can be used for running any PDCP case
8940          * In this case it is uplane 12-bit AES-SNOW DL encap
8941          */
8942         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8943         return test_pdcp_proto_SGL(i, IN_PLACE,
8944                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8945                         RTE_CRYPTO_AUTH_OP_GENERATE,
8946                         pdcp_test_data_in[i],
8947                         pdcp_test_data_in_len[i],
8948                         pdcp_test_data_out[i],
8949                         pdcp_test_data_in_len[i]+4,
8950                         32, 0);
8951 }
8952 static int
8953 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8954 {
8955         /* i can be used for running any PDCP case
8956          * In this case it is uplane 18-bit NULL-NULL DL encap
8957          */
8958         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8959         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8960                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8961                         RTE_CRYPTO_AUTH_OP_GENERATE,
8962                         pdcp_test_data_in[i],
8963                         pdcp_test_data_in_len[i],
8964                         pdcp_test_data_out[i],
8965                         pdcp_test_data_in_len[i]+4,
8966                         32, 128);
8967 }
8968 static int
8969 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8970 {
8971         /* i can be used for running any PDCP case
8972          * In this case it is uplane 18-bit AES DL encap
8973          */
8974         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8975                         + DOWNLINK;
8976         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8977                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8978                         RTE_CRYPTO_AUTH_OP_GENERATE,
8979                         pdcp_test_data_in[i],
8980                         pdcp_test_data_in_len[i],
8981                         pdcp_test_data_out[i],
8982                         pdcp_test_data_in_len[i],
8983                         32, 40);
8984 }
8985 static int
8986 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8987 {
8988         /* i can be used for running any PDCP case
8989          * In this case it is cplane 12-bit AES-ZUC DL encap
8990          */
8991         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8992         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8993                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8994                         RTE_CRYPTO_AUTH_OP_GENERATE,
8995                         pdcp_test_data_in[i],
8996                         pdcp_test_data_in_len[i],
8997                         pdcp_test_data_out[i],
8998                         pdcp_test_data_in_len[i]+4,
8999                         128, 32);
9000 }
9001
9002 static int
9003 test_PDCP_SDAP_PROTO_encap_all(void)
9004 {
9005         int i = 0, size = 0;
9006         int err, all_err = TEST_SUCCESS;
9007         const struct pdcp_sdap_test *cur_test;
9008
9009         size = RTE_DIM(list_pdcp_sdap_tests);
9010
9011         for (i = 0; i < size; i++) {
9012                 cur_test = &list_pdcp_sdap_tests[i];
9013                 err = test_pdcp_proto(
9014                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9015                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9016                         cur_test->in_len, cur_test->data_out,
9017                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9018                         cur_test->param.cipher_alg, cur_test->cipher_key,
9019                         cur_test->param.cipher_key_len,
9020                         cur_test->param.auth_alg,
9021                         cur_test->auth_key, cur_test->param.auth_key_len,
9022                         cur_test->bearer, cur_test->param.domain,
9023                         cur_test->packet_direction, cur_test->sn_size,
9024                         cur_test->hfn,
9025                         cur_test->hfn_threshold, SDAP_ENABLED);
9026                 if (err) {
9027                         printf("\t%d) %s: Encapsulation failed\n",
9028                                         cur_test->test_idx,
9029                                         cur_test->param.name);
9030                         err = TEST_FAILED;
9031                 } else {
9032                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9033                                         cur_test->param.name);
9034                         err = TEST_SUCCESS;
9035                 }
9036                 all_err += err;
9037         }
9038
9039         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9040
9041         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9042 }
9043
9044 static int
9045 test_PDCP_PROTO_short_mac(void)
9046 {
9047         int i = 0, size = 0;
9048         int err, all_err = TEST_SUCCESS;
9049         const struct pdcp_short_mac_test *cur_test;
9050
9051         size = RTE_DIM(list_pdcp_smac_tests);
9052
9053         for (i = 0; i < size; i++) {
9054                 cur_test = &list_pdcp_smac_tests[i];
9055                 err = test_pdcp_proto(
9056                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9057                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9058                         cur_test->in_len, cur_test->data_out,
9059                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9060                         RTE_CRYPTO_CIPHER_NULL, NULL,
9061                         0, cur_test->param.auth_alg,
9062                         cur_test->auth_key, cur_test->param.auth_key_len,
9063                         0, cur_test->param.domain, 0, 0,
9064                         0, 0, 0);
9065                 if (err) {
9066                         printf("\t%d) %s: Short MAC test failed\n",
9067                                         cur_test->test_idx,
9068                                         cur_test->param.name);
9069                         err = TEST_FAILED;
9070                 } else {
9071                         printf("\t%d) %s: Short MAC test PASS\n",
9072                                         cur_test->test_idx,
9073                                         cur_test->param.name);
9074                         rte_hexdump(stdout, "MAC I",
9075                                     cur_test->data_out + cur_test->in_len + 2,
9076                                     2);
9077                         err = TEST_SUCCESS;
9078                 }
9079                 all_err += err;
9080         }
9081
9082         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9083
9084         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9085
9086 }
9087
9088 static int
9089 test_PDCP_SDAP_PROTO_decap_all(void)
9090 {
9091         int i = 0, size = 0;
9092         int err, all_err = TEST_SUCCESS;
9093         const struct pdcp_sdap_test *cur_test;
9094
9095         size = RTE_DIM(list_pdcp_sdap_tests);
9096
9097         for (i = 0; i < size; i++) {
9098                 cur_test = &list_pdcp_sdap_tests[i];
9099                 err = test_pdcp_proto(
9100                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9101                         RTE_CRYPTO_AUTH_OP_VERIFY,
9102                         cur_test->data_out,
9103                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9104                         cur_test->data_in, cur_test->in_len,
9105                         cur_test->param.cipher_alg,
9106                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9107                         cur_test->param.auth_alg, cur_test->auth_key,
9108                         cur_test->param.auth_key_len, cur_test->bearer,
9109                         cur_test->param.domain, cur_test->packet_direction,
9110                         cur_test->sn_size, cur_test->hfn,
9111                         cur_test->hfn_threshold, SDAP_ENABLED);
9112                 if (err) {
9113                         printf("\t%d) %s: Decapsulation failed\n",
9114                                         cur_test->test_idx,
9115                                         cur_test->param.name);
9116                         err = TEST_FAILED;
9117                 } else {
9118                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9119                                         cur_test->param.name);
9120                         err = TEST_SUCCESS;
9121                 }
9122                 all_err += err;
9123         }
9124
9125         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9126
9127         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9128 }
9129
9130 static int
9131 test_ipsec_proto_process(const struct ipsec_test_data td[],
9132                          struct ipsec_test_data res_d[],
9133                          int nb_td,
9134                          bool silent,
9135                          const struct ipsec_test_flags *flags)
9136 {
9137         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9138                                 0x0000, 0x001a};
9139         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9140                                 0xe82c, 0x4887};
9141         struct crypto_testsuite_params *ts_params = &testsuite_params;
9142         struct crypto_unittest_params *ut_params = &unittest_params;
9143         struct rte_security_capability_idx sec_cap_idx;
9144         const struct rte_security_capability *sec_cap;
9145         struct rte_security_ipsec_xform ipsec_xform;
9146         uint8_t dev_id = ts_params->valid_devs[0];
9147         enum rte_security_ipsec_sa_direction dir;
9148         struct ipsec_test_data *res_d_tmp = NULL;
9149         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9150         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9151         int salt_len, i, ret = TEST_SUCCESS;
9152         struct rte_security_ctx *ctx;
9153         uint8_t *input_text;
9154         uint32_t verify;
9155
9156         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9157         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9158
9159         /* Use first test data to create session */
9160
9161         /* Copy IPsec xform */
9162         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9163
9164         dir = ipsec_xform.direction;
9165         verify = flags->tunnel_hdr_verify;
9166
9167         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9168                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9169                         src += 1;
9170                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9171                         dst += 1;
9172         }
9173
9174         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9175                 if (td->ipsec_xform.tunnel.type ==
9176                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9177                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9178                                sizeof(src));
9179                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9180                                sizeof(dst));
9181
9182                         if (flags->df == TEST_IPSEC_SET_DF_0_INNER_1)
9183                                 ipsec_xform.tunnel.ipv4.df = 0;
9184
9185                         if (flags->df == TEST_IPSEC_SET_DF_1_INNER_0)
9186                                 ipsec_xform.tunnel.ipv4.df = 1;
9187
9188                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9189                                 ipsec_xform.tunnel.ipv4.dscp = 0;
9190
9191                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9192                                 ipsec_xform.tunnel.ipv4.dscp =
9193                                                 TEST_IPSEC_DSCP_VAL;
9194
9195                 } else {
9196                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9197                                 ipsec_xform.tunnel.ipv6.dscp = 0;
9198
9199                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9200                                 ipsec_xform.tunnel.ipv6.dscp =
9201                                                 TEST_IPSEC_DSCP_VAL;
9202
9203                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9204                                sizeof(v6_src));
9205                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9206                                sizeof(v6_dst));
9207                 }
9208         }
9209
9210         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9211
9212         sec_cap_idx.action = ut_params->type;
9213         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9214         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9215         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9216         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9217
9218         if (flags->udp_encap)
9219                 ipsec_xform.options.udp_encap = 1;
9220
9221         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9222         if (sec_cap == NULL)
9223                 return TEST_SKIPPED;
9224
9225         /* Copy cipher session parameters */
9226         if (td[0].aead) {
9227                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9228                        sizeof(ut_params->aead_xform));
9229                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9230                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9231
9232                 /* Verify crypto capabilities */
9233                 if (test_ipsec_crypto_caps_aead_verify(
9234                                 sec_cap,
9235                                 &ut_params->aead_xform) != 0) {
9236                         if (!silent)
9237                                 RTE_LOG(INFO, USER1,
9238                                         "Crypto capabilities not supported\n");
9239                         return TEST_SKIPPED;
9240                 }
9241         } else {
9242                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9243                        sizeof(ut_params->cipher_xform));
9244                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9245                        sizeof(ut_params->auth_xform));
9246                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9247                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9248                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9249
9250                 /* Verify crypto capabilities */
9251
9252                 if (test_ipsec_crypto_caps_cipher_verify(
9253                                 sec_cap,
9254                                 &ut_params->cipher_xform) != 0) {
9255                         if (!silent)
9256                                 RTE_LOG(INFO, USER1,
9257                                         "Cipher crypto capabilities not supported\n");
9258                         return TEST_SKIPPED;
9259                 }
9260
9261                 if (test_ipsec_crypto_caps_auth_verify(
9262                                 sec_cap,
9263                                 &ut_params->auth_xform) != 0) {
9264                         if (!silent)
9265                                 RTE_LOG(INFO, USER1,
9266                                         "Auth crypto capabilities not supported\n");
9267                         return TEST_SKIPPED;
9268                 }
9269         }
9270
9271         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9272                 return TEST_SKIPPED;
9273
9274         struct rte_security_session_conf sess_conf = {
9275                 .action_type = ut_params->type,
9276                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9277         };
9278
9279         if (td[0].aead) {
9280                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9281                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9282                 sess_conf.ipsec = ipsec_xform;
9283                 sess_conf.crypto_xform = &ut_params->aead_xform;
9284         } else {
9285                 sess_conf.ipsec = ipsec_xform;
9286                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9287                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9288                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9289                 } else {
9290                         sess_conf.crypto_xform = &ut_params->auth_xform;
9291                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9292                 }
9293         }
9294
9295         /* Create security session */
9296         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9297                                         ts_params->session_mpool,
9298                                         ts_params->session_priv_mpool);
9299
9300         if (ut_params->sec_session == NULL)
9301                 return TEST_SKIPPED;
9302
9303         for (i = 0; i < nb_td; i++) {
9304                 /* Setup source mbuf payload */
9305                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9306                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9307                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9308
9309                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9310                                 td[i].input_text.len);
9311
9312                 memcpy(input_text, td[i].input_text.data,
9313                        td[i].input_text.len);
9314
9315                 if (test_ipsec_pkt_update(input_text, flags))
9316                         return TEST_FAILED;
9317
9318                 /* Generate crypto op data structure */
9319                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9320                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9321                 if (!ut_params->op) {
9322                         printf("TestCase %s line %d: %s\n",
9323                                 __func__, __LINE__,
9324                                 "failed to allocate crypto op");
9325                         ret = TEST_FAILED;
9326                         goto crypto_op_free;
9327                 }
9328
9329                 /* Attach session to operation */
9330                 rte_security_attach_session(ut_params->op,
9331                                             ut_params->sec_session);
9332
9333                 /* Set crypto operation mbufs */
9334                 ut_params->op->sym->m_src = ut_params->ibuf;
9335                 ut_params->op->sym->m_dst = NULL;
9336
9337                 /* Copy IV in crypto operation when IV generation is disabled */
9338                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9339                     ipsec_xform.options.iv_gen_disable == 1) {
9340                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9341                                                                 uint8_t *,
9342                                                                 IV_OFFSET);
9343                         int len;
9344
9345                         if (td[i].aead)
9346                                 len = td[i].xform.aead.aead.iv.length;
9347                         else
9348                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9349
9350                         memcpy(iv, td[i].iv.data, len);
9351                 }
9352
9353                 /* Process crypto operation */
9354                 process_crypto_request(dev_id, ut_params->op);
9355
9356                 ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1);
9357                 if (ret != TEST_SUCCESS)
9358                         goto crypto_op_free;
9359
9360                 if (res_d != NULL)
9361                         res_d_tmp = &res_d[i];
9362
9363                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9364                                               res_d_tmp, silent, flags);
9365                 if (ret != TEST_SUCCESS)
9366                         goto crypto_op_free;
9367
9368                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9369                                               flags, dir);
9370                 if (ret != TEST_SUCCESS)
9371                         goto crypto_op_free;
9372
9373                 rte_crypto_op_free(ut_params->op);
9374                 ut_params->op = NULL;
9375
9376                 rte_pktmbuf_free(ut_params->ibuf);
9377                 ut_params->ibuf = NULL;
9378         }
9379
9380 crypto_op_free:
9381         rte_crypto_op_free(ut_params->op);
9382         ut_params->op = NULL;
9383
9384         rte_pktmbuf_free(ut_params->ibuf);
9385         ut_params->ibuf = NULL;
9386
9387         if (ut_params->sec_session)
9388                 rte_security_session_destroy(ctx, ut_params->sec_session);
9389         ut_params->sec_session = NULL;
9390
9391         return ret;
9392 }
9393
9394 static int
9395 test_ipsec_proto_known_vec(const void *test_data)
9396 {
9397         struct ipsec_test_data td_outb;
9398         struct ipsec_test_flags flags;
9399
9400         memset(&flags, 0, sizeof(flags));
9401
9402         memcpy(&td_outb, test_data, sizeof(td_outb));
9403
9404         if (td_outb.aead ||
9405             td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL) {
9406                 /* Disable IV gen to be able to test with known vectors */
9407                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9408         }
9409
9410         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9411 }
9412
9413 static int
9414 test_ipsec_proto_known_vec_inb(const void *test_data)
9415 {
9416         const struct ipsec_test_data *td = test_data;
9417         struct ipsec_test_flags flags;
9418         struct ipsec_test_data td_inb;
9419
9420         memset(&flags, 0, sizeof(flags));
9421
9422         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9423                 test_ipsec_td_in_from_out(td, &td_inb);
9424         else
9425                 memcpy(&td_inb, td, sizeof(td_inb));
9426
9427         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9428 }
9429
9430 static int
9431 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9432 {
9433         struct ipsec_test_data td_outb;
9434         struct ipsec_test_flags flags;
9435
9436         memset(&flags, 0, sizeof(flags));
9437         flags.fragment = true;
9438
9439         memcpy(&td_outb, test_data, sizeof(td_outb));
9440
9441         /* Disable IV gen to be able to test with known vectors */
9442         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9443
9444         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9445 }
9446
9447 static int
9448 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9449 {
9450         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9451         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9452         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9453         int ret;
9454
9455         if (flags->iv_gen ||
9456             flags->sa_expiry_pkts_soft ||
9457             flags->sa_expiry_pkts_hard)
9458                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9459
9460         for (i = 0; i < RTE_DIM(alg_list); i++) {
9461                 test_ipsec_td_prepare(alg_list[i].param1,
9462                                       alg_list[i].param2,
9463                                       flags,
9464                                       td_outb,
9465                                       nb_pkts);
9466
9467                 if (!td_outb->aead) {
9468                         enum rte_crypto_cipher_algorithm cipher_alg;
9469                         enum rte_crypto_auth_algorithm auth_alg;
9470
9471                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9472                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9473
9474                         /* ICV is not applicable for NULL auth */
9475                         if (flags->icv_corrupt &&
9476                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9477                                 continue;
9478
9479                         /* IV is not applicable for NULL cipher */
9480                         if (flags->iv_gen &&
9481                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9482                                 continue;
9483                 }
9484
9485                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9486                                                flags);
9487                 if (ret == TEST_SKIPPED)
9488                         continue;
9489
9490                 if (ret == TEST_FAILED)
9491                         return TEST_FAILED;
9492
9493                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9494
9495                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9496                                                flags);
9497                 if (ret == TEST_SKIPPED)
9498                         continue;
9499
9500                 if (ret == TEST_FAILED)
9501                         return TEST_FAILED;
9502
9503                 if (flags->display_alg)
9504                         test_ipsec_display_alg(alg_list[i].param1,
9505                                                alg_list[i].param2);
9506
9507                 pass_cnt++;
9508         }
9509
9510         if (pass_cnt > 0)
9511                 return TEST_SUCCESS;
9512         else
9513                 return TEST_SKIPPED;
9514 }
9515
9516 static int
9517 test_ipsec_proto_display_list(const void *data __rte_unused)
9518 {
9519         struct ipsec_test_flags flags;
9520
9521         memset(&flags, 0, sizeof(flags));
9522
9523         flags.display_alg = true;
9524
9525         return test_ipsec_proto_all(&flags);
9526 }
9527
9528 static int
9529 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9530 {
9531         struct ipsec_test_flags flags;
9532
9533         memset(&flags, 0, sizeof(flags));
9534
9535         flags.iv_gen = true;
9536
9537         return test_ipsec_proto_all(&flags);
9538 }
9539
9540 static int
9541 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9542 {
9543         struct ipsec_test_flags flags;
9544
9545         memset(&flags, 0, sizeof(flags));
9546
9547         flags.sa_expiry_pkts_soft = true;
9548
9549         return test_ipsec_proto_all(&flags);
9550 }
9551
9552 static int
9553 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9554 {
9555         struct ipsec_test_flags flags;
9556
9557         memset(&flags, 0, sizeof(flags));
9558
9559         flags.sa_expiry_pkts_hard = true;
9560
9561         return test_ipsec_proto_all(&flags);
9562 }
9563
9564 static int
9565 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9566 {
9567         struct ipsec_test_flags flags;
9568
9569         memset(&flags, 0, sizeof(flags));
9570
9571         flags.icv_corrupt = true;
9572
9573         return test_ipsec_proto_all(&flags);
9574 }
9575
9576 static int
9577 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9578 {
9579         struct ipsec_test_flags flags;
9580
9581         memset(&flags, 0, sizeof(flags));
9582
9583         flags.udp_encap = true;
9584
9585         return test_ipsec_proto_all(&flags);
9586 }
9587
9588 static int
9589 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9590 {
9591         struct ipsec_test_flags flags;
9592
9593         memset(&flags, 0, sizeof(flags));
9594
9595         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9596
9597         return test_ipsec_proto_all(&flags);
9598 }
9599
9600 static int
9601 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9602 {
9603         struct ipsec_test_flags flags;
9604
9605         memset(&flags, 0, sizeof(flags));
9606
9607         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9608
9609         return test_ipsec_proto_all(&flags);
9610 }
9611
9612 static int
9613 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9614 {
9615         struct ipsec_test_flags flags;
9616
9617         memset(&flags, 0, sizeof(flags));
9618
9619         flags.udp_encap = true;
9620         flags.udp_ports_verify = true;
9621
9622         return test_ipsec_proto_all(&flags);
9623 }
9624
9625 static int
9626 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9627 {
9628         struct ipsec_test_flags flags;
9629
9630         memset(&flags, 0, sizeof(flags));
9631
9632         flags.ip_csum = true;
9633
9634         return test_ipsec_proto_all(&flags);
9635 }
9636
9637 static int
9638 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9639 {
9640         struct ipsec_test_flags flags;
9641
9642         memset(&flags, 0, sizeof(flags));
9643
9644         flags.l4_csum = true;
9645
9646         return test_ipsec_proto_all(&flags);
9647 }
9648
9649 static int
9650 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9651 {
9652         struct ipsec_test_flags flags;
9653
9654         memset(&flags, 0, sizeof(flags));
9655
9656         flags.ipv6 = false;
9657         flags.tunnel_ipv6 = false;
9658
9659         return test_ipsec_proto_all(&flags);
9660 }
9661
9662 static int
9663 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9664 {
9665         struct ipsec_test_flags flags;
9666
9667         memset(&flags, 0, sizeof(flags));
9668
9669         flags.ipv6 = true;
9670         flags.tunnel_ipv6 = true;
9671
9672         return test_ipsec_proto_all(&flags);
9673 }
9674
9675 static int
9676 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9677 {
9678         struct ipsec_test_flags flags;
9679
9680         memset(&flags, 0, sizeof(flags));
9681
9682         flags.ipv6 = false;
9683         flags.tunnel_ipv6 = true;
9684
9685         return test_ipsec_proto_all(&flags);
9686 }
9687
9688 static int
9689 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9690 {
9691         struct ipsec_test_flags flags;
9692
9693         memset(&flags, 0, sizeof(flags));
9694
9695         flags.ipv6 = true;
9696         flags.tunnel_ipv6 = false;
9697
9698         return test_ipsec_proto_all(&flags);
9699 }
9700
9701 static int
9702 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9703 {
9704         struct ipsec_test_flags flags;
9705
9706         memset(&flags, 0, sizeof(flags));
9707
9708         flags.ipv6 = false;
9709         flags.transport = true;
9710
9711         return test_ipsec_proto_all(&flags);
9712 }
9713
9714 static int
9715 test_ipsec_proto_stats(const void *data __rte_unused)
9716 {
9717         struct ipsec_test_flags flags;
9718
9719         memset(&flags, 0, sizeof(flags));
9720
9721         flags.stats_success = true;
9722
9723         return test_ipsec_proto_all(&flags);
9724 }
9725
9726 static int
9727 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9728 {
9729         struct ipsec_test_flags flags;
9730
9731         memset(&flags, 0, sizeof(flags));
9732
9733         flags.fragment = true;
9734
9735         return test_ipsec_proto_all(&flags);
9736
9737 }
9738
9739 static int
9740 test_ipsec_proto_copy_df_inner_0(const void *data __rte_unused)
9741 {
9742         struct ipsec_test_flags flags;
9743
9744         memset(&flags, 0, sizeof(flags));
9745
9746         flags.df = TEST_IPSEC_COPY_DF_INNER_0;
9747
9748         return test_ipsec_proto_all(&flags);
9749 }
9750
9751 static int
9752 test_ipsec_proto_copy_df_inner_1(const void *data __rte_unused)
9753 {
9754         struct ipsec_test_flags flags;
9755
9756         memset(&flags, 0, sizeof(flags));
9757
9758         flags.df = TEST_IPSEC_COPY_DF_INNER_1;
9759
9760         return test_ipsec_proto_all(&flags);
9761 }
9762
9763 static int
9764 test_ipsec_proto_set_df_0_inner_1(const void *data __rte_unused)
9765 {
9766         struct ipsec_test_flags flags;
9767
9768         memset(&flags, 0, sizeof(flags));
9769
9770         flags.df = TEST_IPSEC_SET_DF_0_INNER_1;
9771
9772         return test_ipsec_proto_all(&flags);
9773 }
9774
9775 static int
9776 test_ipsec_proto_set_df_1_inner_0(const void *data __rte_unused)
9777 {
9778         struct ipsec_test_flags flags;
9779
9780         memset(&flags, 0, sizeof(flags));
9781
9782         flags.df = TEST_IPSEC_SET_DF_1_INNER_0;
9783
9784         return test_ipsec_proto_all(&flags);
9785 }
9786
9787 static int
9788 test_ipsec_proto_ipv4_copy_dscp_inner_0(const void *data __rte_unused)
9789 {
9790         struct ipsec_test_flags flags;
9791
9792         memset(&flags, 0, sizeof(flags));
9793
9794         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9795
9796         return test_ipsec_proto_all(&flags);
9797 }
9798
9799 static int
9800 test_ipsec_proto_ipv4_copy_dscp_inner_1(const void *data __rte_unused)
9801 {
9802         struct ipsec_test_flags flags;
9803
9804         memset(&flags, 0, sizeof(flags));
9805
9806         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9807
9808         return test_ipsec_proto_all(&flags);
9809 }
9810
9811 static int
9812 test_ipsec_proto_ipv4_set_dscp_0_inner_1(const void *data __rte_unused)
9813 {
9814         struct ipsec_test_flags flags;
9815
9816         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9817                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9818                 return TEST_SKIPPED;
9819
9820         memset(&flags, 0, sizeof(flags));
9821
9822         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9823
9824         return test_ipsec_proto_all(&flags);
9825 }
9826
9827 static int
9828 test_ipsec_proto_ipv4_set_dscp_1_inner_0(const void *data __rte_unused)
9829 {
9830         struct ipsec_test_flags flags;
9831
9832         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9833                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9834                 return TEST_SKIPPED;
9835
9836         memset(&flags, 0, sizeof(flags));
9837
9838         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
9839
9840         return test_ipsec_proto_all(&flags);
9841 }
9842
9843 static int
9844 test_ipsec_proto_ipv6_copy_dscp_inner_0(const void *data __rte_unused)
9845 {
9846         struct ipsec_test_flags flags;
9847
9848         memset(&flags, 0, sizeof(flags));
9849
9850         flags.ipv6 = true;
9851         flags.tunnel_ipv6 = true;
9852         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9853
9854         return test_ipsec_proto_all(&flags);
9855 }
9856
9857 static int
9858 test_ipsec_proto_ipv6_copy_dscp_inner_1(const void *data __rte_unused)
9859 {
9860         struct ipsec_test_flags flags;
9861
9862         memset(&flags, 0, sizeof(flags));
9863
9864         flags.ipv6 = true;
9865         flags.tunnel_ipv6 = true;
9866         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9867
9868         return test_ipsec_proto_all(&flags);
9869 }
9870
9871 static int
9872 test_ipsec_proto_ipv6_set_dscp_0_inner_1(const void *data __rte_unused)
9873 {
9874         struct ipsec_test_flags flags;
9875
9876         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9877                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9878                 return TEST_SKIPPED;
9879
9880         memset(&flags, 0, sizeof(flags));
9881
9882         flags.ipv6 = true;
9883         flags.tunnel_ipv6 = true;
9884         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9885
9886         return test_ipsec_proto_all(&flags);
9887 }
9888
9889 static int
9890 test_ipsec_proto_ipv6_set_dscp_1_inner_0(const void *data __rte_unused)
9891 {
9892         struct ipsec_test_flags flags;
9893
9894         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9895                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9896                 return TEST_SKIPPED;
9897
9898         memset(&flags, 0, sizeof(flags));
9899
9900         flags.ipv6 = true;
9901         flags.tunnel_ipv6 = true;
9902         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
9903
9904         return test_ipsec_proto_all(&flags);
9905 }
9906
9907 static int
9908 test_PDCP_PROTO_all(void)
9909 {
9910         struct crypto_testsuite_params *ts_params = &testsuite_params;
9911         struct crypto_unittest_params *ut_params = &unittest_params;
9912         struct rte_cryptodev_info dev_info;
9913         int status;
9914
9915         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
9916         uint64_t feat_flags = dev_info.feature_flags;
9917
9918         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
9919                 return TEST_SKIPPED;
9920
9921         /* Set action type */
9922         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9923                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9924                 gbl_action_type;
9925
9926         if (security_proto_supported(ut_params->type,
9927                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
9928                 return TEST_SKIPPED;
9929
9930         status = test_PDCP_PROTO_cplane_encap_all();
9931         status += test_PDCP_PROTO_cplane_decap_all();
9932         status += test_PDCP_PROTO_uplane_encap_all();
9933         status += test_PDCP_PROTO_uplane_decap_all();
9934         status += test_PDCP_PROTO_SGL_in_place_32B();
9935         status += test_PDCP_PROTO_SGL_oop_32B_128B();
9936         status += test_PDCP_PROTO_SGL_oop_32B_40B();
9937         status += test_PDCP_PROTO_SGL_oop_128B_32B();
9938         status += test_PDCP_SDAP_PROTO_encap_all();
9939         status += test_PDCP_SDAP_PROTO_decap_all();
9940         status += test_PDCP_PROTO_short_mac();
9941
9942         if (status)
9943                 return TEST_FAILED;
9944         else
9945                 return TEST_SUCCESS;
9946 }
9947
9948 static int
9949 test_docsis_proto_uplink(const void *data)
9950 {
9951         const struct docsis_test_data *d_td = data;
9952         struct crypto_testsuite_params *ts_params = &testsuite_params;
9953         struct crypto_unittest_params *ut_params = &unittest_params;
9954         uint8_t *plaintext = NULL;
9955         uint8_t *ciphertext = NULL;
9956         uint8_t *iv_ptr;
9957         int32_t cipher_len, crc_len;
9958         uint32_t crc_data_len;
9959         int ret = TEST_SUCCESS;
9960
9961         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
9962                                         rte_cryptodev_get_sec_ctx(
9963                                                 ts_params->valid_devs[0]);
9964
9965         /* Verify the capabilities */
9966         struct rte_security_capability_idx sec_cap_idx;
9967         const struct rte_security_capability *sec_cap;
9968         const struct rte_cryptodev_capabilities *crypto_cap;
9969         const struct rte_cryptodev_symmetric_capability *sym_cap;
9970         int j = 0;
9971
9972         /* Set action type */
9973         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
9974                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
9975                 gbl_action_type;
9976
9977         if (security_proto_supported(ut_params->type,
9978                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
9979                 return TEST_SKIPPED;
9980
9981         sec_cap_idx.action = ut_params->type;
9982         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
9983         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
9984
9985         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9986         if (sec_cap == NULL)
9987                 return TEST_SKIPPED;
9988
9989         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
9990                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
9991                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
9992                                 crypto_cap->sym.xform_type ==
9993                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
9994                                 crypto_cap->sym.cipher.algo ==
9995                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
9996                         sym_cap = &crypto_cap->sym;
9997                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
9998                                                 d_td->key.len,
9999                                                 d_td->iv.len) == 0)
10000                                 break;
10001                 }
10002         }
10003
10004         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10005                 return TEST_SKIPPED;
10006
10007         /* Setup source mbuf payload */
10008         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10009         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10010                         rte_pktmbuf_tailroom(ut_params->ibuf));
10011
10012         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10013                         d_td->ciphertext.len);
10014
10015         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
10016
10017         /* Setup cipher session parameters */
10018         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10019         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10020         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
10021         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10022         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10023         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10024         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10025         ut_params->cipher_xform.next = NULL;
10026
10027         /* Setup DOCSIS session parameters */
10028         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
10029
10030         struct rte_security_session_conf sess_conf = {
10031                 .action_type = ut_params->type,
10032                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10033                 .docsis = ut_params->docsis_xform,
10034                 .crypto_xform = &ut_params->cipher_xform,
10035         };
10036
10037         /* Create security session */
10038         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10039                                         ts_params->session_mpool,
10040                                         ts_params->session_priv_mpool);
10041
10042         if (!ut_params->sec_session) {
10043                 printf("Test function %s line %u: failed to allocate session\n",
10044                         __func__, __LINE__);
10045                 ret = TEST_FAILED;
10046                 goto on_err;
10047         }
10048
10049         /* Generate crypto op data structure */
10050         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10051                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10052         if (!ut_params->op) {
10053                 printf("Test function %s line %u: failed to allocate symmetric "
10054                         "crypto operation\n", __func__, __LINE__);
10055                 ret = TEST_FAILED;
10056                 goto on_err;
10057         }
10058
10059         /* Setup CRC operation parameters */
10060         crc_len = d_td->ciphertext.no_crc == false ?
10061                         (d_td->ciphertext.len -
10062                                 d_td->ciphertext.crc_offset -
10063                                 RTE_ETHER_CRC_LEN) :
10064                         0;
10065         crc_len = crc_len > 0 ? crc_len : 0;
10066         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
10067         ut_params->op->sym->auth.data.length = crc_len;
10068         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
10069
10070         /* Setup cipher operation parameters */
10071         cipher_len = d_td->ciphertext.no_cipher == false ?
10072                         (d_td->ciphertext.len -
10073                                 d_td->ciphertext.cipher_offset) :
10074                         0;
10075         cipher_len = cipher_len > 0 ? cipher_len : 0;
10076         ut_params->op->sym->cipher.data.length = cipher_len;
10077         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
10078
10079         /* Setup cipher IV */
10080         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10081         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10082
10083         /* Attach session to operation */
10084         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10085
10086         /* Set crypto operation mbufs */
10087         ut_params->op->sym->m_src = ut_params->ibuf;
10088         ut_params->op->sym->m_dst = NULL;
10089
10090         /* Process crypto operation */
10091         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10092                         NULL) {
10093                 printf("Test function %s line %u: failed to process security "
10094                         "crypto op\n", __func__, __LINE__);
10095                 ret = TEST_FAILED;
10096                 goto on_err;
10097         }
10098
10099         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10100                 printf("Test function %s line %u: failed to process crypto op\n",
10101                         __func__, __LINE__);
10102                 ret = TEST_FAILED;
10103                 goto on_err;
10104         }
10105
10106         /* Validate plaintext */
10107         plaintext = ciphertext;
10108
10109         if (memcmp(plaintext, d_td->plaintext.data,
10110                         d_td->plaintext.len - crc_data_len)) {
10111                 printf("Test function %s line %u: plaintext not as expected\n",
10112                         __func__, __LINE__);
10113                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
10114                                 d_td->plaintext.len);
10115                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
10116                 ret = TEST_FAILED;
10117                 goto on_err;
10118         }
10119
10120 on_err:
10121         rte_crypto_op_free(ut_params->op);
10122         ut_params->op = NULL;
10123
10124         if (ut_params->sec_session)
10125                 rte_security_session_destroy(ctx, ut_params->sec_session);
10126         ut_params->sec_session = NULL;
10127
10128         rte_pktmbuf_free(ut_params->ibuf);
10129         ut_params->ibuf = NULL;
10130
10131         return ret;
10132 }
10133
10134 static int
10135 test_docsis_proto_downlink(const void *data)
10136 {
10137         const struct docsis_test_data *d_td = data;
10138         struct crypto_testsuite_params *ts_params = &testsuite_params;
10139         struct crypto_unittest_params *ut_params = &unittest_params;
10140         uint8_t *plaintext = NULL;
10141         uint8_t *ciphertext = NULL;
10142         uint8_t *iv_ptr;
10143         int32_t cipher_len, crc_len;
10144         int ret = TEST_SUCCESS;
10145
10146         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10147                                         rte_cryptodev_get_sec_ctx(
10148                                                 ts_params->valid_devs[0]);
10149
10150         /* Verify the capabilities */
10151         struct rte_security_capability_idx sec_cap_idx;
10152         const struct rte_security_capability *sec_cap;
10153         const struct rte_cryptodev_capabilities *crypto_cap;
10154         const struct rte_cryptodev_symmetric_capability *sym_cap;
10155         int j = 0;
10156
10157         /* Set action type */
10158         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10159                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10160                 gbl_action_type;
10161
10162         if (security_proto_supported(ut_params->type,
10163                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10164                 return TEST_SKIPPED;
10165
10166         sec_cap_idx.action = ut_params->type;
10167         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10168         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10169
10170         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10171         if (sec_cap == NULL)
10172                 return TEST_SKIPPED;
10173
10174         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10175                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10176                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10177                                 crypto_cap->sym.xform_type ==
10178                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10179                                 crypto_cap->sym.cipher.algo ==
10180                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10181                         sym_cap = &crypto_cap->sym;
10182                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10183                                                 d_td->key.len,
10184                                                 d_td->iv.len) == 0)
10185                                 break;
10186                 }
10187         }
10188
10189         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10190                 return TEST_SKIPPED;
10191
10192         /* Setup source mbuf payload */
10193         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10194         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10195                         rte_pktmbuf_tailroom(ut_params->ibuf));
10196
10197         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10198                         d_td->plaintext.len);
10199
10200         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10201
10202         /* Setup cipher session parameters */
10203         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10204         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10205         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10206         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10207         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10208         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10209         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10210         ut_params->cipher_xform.next = NULL;
10211
10212         /* Setup DOCSIS session parameters */
10213         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10214
10215         struct rte_security_session_conf sess_conf = {
10216                 .action_type = ut_params->type,
10217                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10218                 .docsis = ut_params->docsis_xform,
10219                 .crypto_xform = &ut_params->cipher_xform,
10220         };
10221
10222         /* Create security session */
10223         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10224                                         ts_params->session_mpool,
10225                                         ts_params->session_priv_mpool);
10226
10227         if (!ut_params->sec_session) {
10228                 printf("Test function %s line %u: failed to allocate session\n",
10229                         __func__, __LINE__);
10230                 ret = TEST_FAILED;
10231                 goto on_err;
10232         }
10233
10234         /* Generate crypto op data structure */
10235         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10236                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10237         if (!ut_params->op) {
10238                 printf("Test function %s line %u: failed to allocate symmetric "
10239                         "crypto operation\n", __func__, __LINE__);
10240                 ret = TEST_FAILED;
10241                 goto on_err;
10242         }
10243
10244         /* Setup CRC operation parameters */
10245         crc_len = d_td->plaintext.no_crc == false ?
10246                         (d_td->plaintext.len -
10247                                 d_td->plaintext.crc_offset -
10248                                 RTE_ETHER_CRC_LEN) :
10249                         0;
10250         crc_len = crc_len > 0 ? crc_len : 0;
10251         ut_params->op->sym->auth.data.length = crc_len;
10252         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10253
10254         /* Setup cipher operation parameters */
10255         cipher_len = d_td->plaintext.no_cipher == false ?
10256                         (d_td->plaintext.len -
10257                                 d_td->plaintext.cipher_offset) :
10258                         0;
10259         cipher_len = cipher_len > 0 ? cipher_len : 0;
10260         ut_params->op->sym->cipher.data.length = cipher_len;
10261         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10262
10263         /* Setup cipher IV */
10264         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10265         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10266
10267         /* Attach session to operation */
10268         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10269
10270         /* Set crypto operation mbufs */
10271         ut_params->op->sym->m_src = ut_params->ibuf;
10272         ut_params->op->sym->m_dst = NULL;
10273
10274         /* Process crypto operation */
10275         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10276                         NULL) {
10277                 printf("Test function %s line %u: failed to process crypto op\n",
10278                         __func__, __LINE__);
10279                 ret = TEST_FAILED;
10280                 goto on_err;
10281         }
10282
10283         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10284                 printf("Test function %s line %u: crypto op processing failed\n",
10285                         __func__, __LINE__);
10286                 ret = TEST_FAILED;
10287                 goto on_err;
10288         }
10289
10290         /* Validate ciphertext */
10291         ciphertext = plaintext;
10292
10293         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10294                 printf("Test function %s line %u: plaintext not as expected\n",
10295                         __func__, __LINE__);
10296                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10297                                 d_td->ciphertext.len);
10298                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10299                 ret = TEST_FAILED;
10300                 goto on_err;
10301         }
10302
10303 on_err:
10304         rte_crypto_op_free(ut_params->op);
10305         ut_params->op = NULL;
10306
10307         if (ut_params->sec_session)
10308                 rte_security_session_destroy(ctx, ut_params->sec_session);
10309         ut_params->sec_session = NULL;
10310
10311         rte_pktmbuf_free(ut_params->ibuf);
10312         ut_params->ibuf = NULL;
10313
10314         return ret;
10315 }
10316 #endif
10317
10318 static int
10319 test_AES_GCM_authenticated_encryption_test_case_1(void)
10320 {
10321         return test_authenticated_encryption(&gcm_test_case_1);
10322 }
10323
10324 static int
10325 test_AES_GCM_authenticated_encryption_test_case_2(void)
10326 {
10327         return test_authenticated_encryption(&gcm_test_case_2);
10328 }
10329
10330 static int
10331 test_AES_GCM_authenticated_encryption_test_case_3(void)
10332 {
10333         return test_authenticated_encryption(&gcm_test_case_3);
10334 }
10335
10336 static int
10337 test_AES_GCM_authenticated_encryption_test_case_4(void)
10338 {
10339         return test_authenticated_encryption(&gcm_test_case_4);
10340 }
10341
10342 static int
10343 test_AES_GCM_authenticated_encryption_test_case_5(void)
10344 {
10345         return test_authenticated_encryption(&gcm_test_case_5);
10346 }
10347
10348 static int
10349 test_AES_GCM_authenticated_encryption_test_case_6(void)
10350 {
10351         return test_authenticated_encryption(&gcm_test_case_6);
10352 }
10353
10354 static int
10355 test_AES_GCM_authenticated_encryption_test_case_7(void)
10356 {
10357         return test_authenticated_encryption(&gcm_test_case_7);
10358 }
10359
10360 static int
10361 test_AES_GCM_authenticated_encryption_test_case_8(void)
10362 {
10363         return test_authenticated_encryption(&gcm_test_case_8);
10364 }
10365
10366 static int
10367 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10368 {
10369         return test_authenticated_encryption(&gcm_J0_test_case_1);
10370 }
10371
10372 static int
10373 test_AES_GCM_auth_encryption_test_case_192_1(void)
10374 {
10375         return test_authenticated_encryption(&gcm_test_case_192_1);
10376 }
10377
10378 static int
10379 test_AES_GCM_auth_encryption_test_case_192_2(void)
10380 {
10381         return test_authenticated_encryption(&gcm_test_case_192_2);
10382 }
10383
10384 static int
10385 test_AES_GCM_auth_encryption_test_case_192_3(void)
10386 {
10387         return test_authenticated_encryption(&gcm_test_case_192_3);
10388 }
10389
10390 static int
10391 test_AES_GCM_auth_encryption_test_case_192_4(void)
10392 {
10393         return test_authenticated_encryption(&gcm_test_case_192_4);
10394 }
10395
10396 static int
10397 test_AES_GCM_auth_encryption_test_case_192_5(void)
10398 {
10399         return test_authenticated_encryption(&gcm_test_case_192_5);
10400 }
10401
10402 static int
10403 test_AES_GCM_auth_encryption_test_case_192_6(void)
10404 {
10405         return test_authenticated_encryption(&gcm_test_case_192_6);
10406 }
10407
10408 static int
10409 test_AES_GCM_auth_encryption_test_case_192_7(void)
10410 {
10411         return test_authenticated_encryption(&gcm_test_case_192_7);
10412 }
10413
10414 static int
10415 test_AES_GCM_auth_encryption_test_case_256_1(void)
10416 {
10417         return test_authenticated_encryption(&gcm_test_case_256_1);
10418 }
10419
10420 static int
10421 test_AES_GCM_auth_encryption_test_case_256_2(void)
10422 {
10423         return test_authenticated_encryption(&gcm_test_case_256_2);
10424 }
10425
10426 static int
10427 test_AES_GCM_auth_encryption_test_case_256_3(void)
10428 {
10429         return test_authenticated_encryption(&gcm_test_case_256_3);
10430 }
10431
10432 static int
10433 test_AES_GCM_auth_encryption_test_case_256_4(void)
10434 {
10435         return test_authenticated_encryption(&gcm_test_case_256_4);
10436 }
10437
10438 static int
10439 test_AES_GCM_auth_encryption_test_case_256_5(void)
10440 {
10441         return test_authenticated_encryption(&gcm_test_case_256_5);
10442 }
10443
10444 static int
10445 test_AES_GCM_auth_encryption_test_case_256_6(void)
10446 {
10447         return test_authenticated_encryption(&gcm_test_case_256_6);
10448 }
10449
10450 static int
10451 test_AES_GCM_auth_encryption_test_case_256_7(void)
10452 {
10453         return test_authenticated_encryption(&gcm_test_case_256_7);
10454 }
10455
10456 static int
10457 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10458 {
10459         return test_authenticated_encryption(&gcm_test_case_aad_1);
10460 }
10461
10462 static int
10463 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10464 {
10465         return test_authenticated_encryption(&gcm_test_case_aad_2);
10466 }
10467
10468 static int
10469 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10470 {
10471         struct aead_test_data tdata;
10472         int res;
10473
10474         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10475         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10476         tdata.iv.data[0] += 1;
10477         res = test_authenticated_encryption(&tdata);
10478         if (res == TEST_SKIPPED)
10479                 return res;
10480         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10481         return TEST_SUCCESS;
10482 }
10483
10484 static int
10485 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10486 {
10487         struct aead_test_data tdata;
10488         int res;
10489
10490         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10491         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10492         tdata.plaintext.data[0] += 1;
10493         res = test_authenticated_encryption(&tdata);
10494         if (res == TEST_SKIPPED)
10495                 return res;
10496         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10497         return TEST_SUCCESS;
10498 }
10499
10500 static int
10501 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10502 {
10503         struct aead_test_data tdata;
10504         int res;
10505
10506         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10507         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10508         tdata.ciphertext.data[0] += 1;
10509         res = test_authenticated_encryption(&tdata);
10510         if (res == TEST_SKIPPED)
10511                 return res;
10512         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10513         return TEST_SUCCESS;
10514 }
10515
10516 static int
10517 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10518 {
10519         struct aead_test_data tdata;
10520         int res;
10521
10522         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10523         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10524         tdata.aad.len += 1;
10525         res = test_authenticated_encryption(&tdata);
10526         if (res == TEST_SKIPPED)
10527                 return res;
10528         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10529         return TEST_SUCCESS;
10530 }
10531
10532 static int
10533 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10534 {
10535         struct aead_test_data tdata;
10536         uint8_t aad[gcm_test_case_7.aad.len];
10537         int res;
10538
10539         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10540         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10541         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10542         aad[0] += 1;
10543         tdata.aad.data = aad;
10544         res = test_authenticated_encryption(&tdata);
10545         if (res == TEST_SKIPPED)
10546                 return res;
10547         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10548         return TEST_SUCCESS;
10549 }
10550
10551 static int
10552 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10553 {
10554         struct aead_test_data tdata;
10555         int res;
10556
10557         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10558         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10559         tdata.auth_tag.data[0] += 1;
10560         res = test_authenticated_encryption(&tdata);
10561         if (res == TEST_SKIPPED)
10562                 return res;
10563         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10564         return TEST_SUCCESS;
10565 }
10566
10567 static int
10568 test_authenticated_decryption(const struct aead_test_data *tdata)
10569 {
10570         struct crypto_testsuite_params *ts_params = &testsuite_params;
10571         struct crypto_unittest_params *ut_params = &unittest_params;
10572
10573         int retval;
10574         uint8_t *plaintext;
10575         uint32_t i;
10576         struct rte_cryptodev_info dev_info;
10577
10578         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10579         uint64_t feat_flags = dev_info.feature_flags;
10580
10581         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10582                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10583                 printf("Device doesn't support RAW data-path APIs.\n");
10584                 return TEST_SKIPPED;
10585         }
10586
10587         /* Verify the capabilities */
10588         struct rte_cryptodev_sym_capability_idx cap_idx;
10589         const struct rte_cryptodev_symmetric_capability *capability;
10590         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10591         cap_idx.algo.aead = tdata->algo;
10592         capability = rte_cryptodev_sym_capability_get(
10593                         ts_params->valid_devs[0], &cap_idx);
10594         if (capability == NULL)
10595                 return TEST_SKIPPED;
10596         if (rte_cryptodev_sym_capability_check_aead(
10597                         capability, tdata->key.len, tdata->auth_tag.len,
10598                         tdata->aad.len, tdata->iv.len))
10599                 return TEST_SKIPPED;
10600
10601         /* Create AEAD session */
10602         retval = create_aead_session(ts_params->valid_devs[0],
10603                         tdata->algo,
10604                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10605                         tdata->key.data, tdata->key.len,
10606                         tdata->aad.len, tdata->auth_tag.len,
10607                         tdata->iv.len);
10608         if (retval < 0)
10609                 return retval;
10610
10611         /* alloc mbuf and set payload */
10612         if (tdata->aad.len > MBUF_SIZE) {
10613                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10614                 /* Populate full size of add data */
10615                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10616                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10617         } else
10618                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10619
10620         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10621                         rte_pktmbuf_tailroom(ut_params->ibuf));
10622
10623         /* Create AEAD operation */
10624         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10625         if (retval < 0)
10626                 return retval;
10627
10628         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10629
10630         ut_params->op->sym->m_src = ut_params->ibuf;
10631
10632         /* Process crypto operation */
10633         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10634                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10635         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10636                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10637                                 ut_params->op, 0, 0, 0, 0);
10638         else
10639                 TEST_ASSERT_NOT_NULL(
10640                         process_crypto_request(ts_params->valid_devs[0],
10641                         ut_params->op), "failed to process sym crypto op");
10642
10643         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10644                         "crypto op processing failed");
10645
10646         if (ut_params->op->sym->m_dst)
10647                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10648                                 uint8_t *);
10649         else
10650                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10651                                 uint8_t *,
10652                                 ut_params->op->sym->cipher.data.offset);
10653
10654         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10655
10656         /* Validate obuf */
10657         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10658                         plaintext,
10659                         tdata->plaintext.data,
10660                         tdata->plaintext.len,
10661                         "Plaintext data not as expected");
10662
10663         TEST_ASSERT_EQUAL(ut_params->op->status,
10664                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10665                         "Authentication failed");
10666
10667         return 0;
10668 }
10669
10670 static int
10671 test_AES_GCM_authenticated_decryption_test_case_1(void)
10672 {
10673         return test_authenticated_decryption(&gcm_test_case_1);
10674 }
10675
10676 static int
10677 test_AES_GCM_authenticated_decryption_test_case_2(void)
10678 {
10679         return test_authenticated_decryption(&gcm_test_case_2);
10680 }
10681
10682 static int
10683 test_AES_GCM_authenticated_decryption_test_case_3(void)
10684 {
10685         return test_authenticated_decryption(&gcm_test_case_3);
10686 }
10687
10688 static int
10689 test_AES_GCM_authenticated_decryption_test_case_4(void)
10690 {
10691         return test_authenticated_decryption(&gcm_test_case_4);
10692 }
10693
10694 static int
10695 test_AES_GCM_authenticated_decryption_test_case_5(void)
10696 {
10697         return test_authenticated_decryption(&gcm_test_case_5);
10698 }
10699
10700 static int
10701 test_AES_GCM_authenticated_decryption_test_case_6(void)
10702 {
10703         return test_authenticated_decryption(&gcm_test_case_6);
10704 }
10705
10706 static int
10707 test_AES_GCM_authenticated_decryption_test_case_7(void)
10708 {
10709         return test_authenticated_decryption(&gcm_test_case_7);
10710 }
10711
10712 static int
10713 test_AES_GCM_authenticated_decryption_test_case_8(void)
10714 {
10715         return test_authenticated_decryption(&gcm_test_case_8);
10716 }
10717
10718 static int
10719 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10720 {
10721         return test_authenticated_decryption(&gcm_J0_test_case_1);
10722 }
10723
10724 static int
10725 test_AES_GCM_auth_decryption_test_case_192_1(void)
10726 {
10727         return test_authenticated_decryption(&gcm_test_case_192_1);
10728 }
10729
10730 static int
10731 test_AES_GCM_auth_decryption_test_case_192_2(void)
10732 {
10733         return test_authenticated_decryption(&gcm_test_case_192_2);
10734 }
10735
10736 static int
10737 test_AES_GCM_auth_decryption_test_case_192_3(void)
10738 {
10739         return test_authenticated_decryption(&gcm_test_case_192_3);
10740 }
10741
10742 static int
10743 test_AES_GCM_auth_decryption_test_case_192_4(void)
10744 {
10745         return test_authenticated_decryption(&gcm_test_case_192_4);
10746 }
10747
10748 static int
10749 test_AES_GCM_auth_decryption_test_case_192_5(void)
10750 {
10751         return test_authenticated_decryption(&gcm_test_case_192_5);
10752 }
10753
10754 static int
10755 test_AES_GCM_auth_decryption_test_case_192_6(void)
10756 {
10757         return test_authenticated_decryption(&gcm_test_case_192_6);
10758 }
10759
10760 static int
10761 test_AES_GCM_auth_decryption_test_case_192_7(void)
10762 {
10763         return test_authenticated_decryption(&gcm_test_case_192_7);
10764 }
10765
10766 static int
10767 test_AES_GCM_auth_decryption_test_case_256_1(void)
10768 {
10769         return test_authenticated_decryption(&gcm_test_case_256_1);
10770 }
10771
10772 static int
10773 test_AES_GCM_auth_decryption_test_case_256_2(void)
10774 {
10775         return test_authenticated_decryption(&gcm_test_case_256_2);
10776 }
10777
10778 static int
10779 test_AES_GCM_auth_decryption_test_case_256_3(void)
10780 {
10781         return test_authenticated_decryption(&gcm_test_case_256_3);
10782 }
10783
10784 static int
10785 test_AES_GCM_auth_decryption_test_case_256_4(void)
10786 {
10787         return test_authenticated_decryption(&gcm_test_case_256_4);
10788 }
10789
10790 static int
10791 test_AES_GCM_auth_decryption_test_case_256_5(void)
10792 {
10793         return test_authenticated_decryption(&gcm_test_case_256_5);
10794 }
10795
10796 static int
10797 test_AES_GCM_auth_decryption_test_case_256_6(void)
10798 {
10799         return test_authenticated_decryption(&gcm_test_case_256_6);
10800 }
10801
10802 static int
10803 test_AES_GCM_auth_decryption_test_case_256_7(void)
10804 {
10805         return test_authenticated_decryption(&gcm_test_case_256_7);
10806 }
10807
10808 static int
10809 test_AES_GCM_auth_decryption_test_case_aad_1(void)
10810 {
10811         return test_authenticated_decryption(&gcm_test_case_aad_1);
10812 }
10813
10814 static int
10815 test_AES_GCM_auth_decryption_test_case_aad_2(void)
10816 {
10817         return test_authenticated_decryption(&gcm_test_case_aad_2);
10818 }
10819
10820 static int
10821 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
10822 {
10823         struct aead_test_data tdata;
10824         int res;
10825
10826         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10827         tdata.iv.data[0] += 1;
10828         res = test_authenticated_decryption(&tdata);
10829         if (res == TEST_SKIPPED)
10830                 return res;
10831         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10832         return TEST_SUCCESS;
10833 }
10834
10835 static int
10836 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
10837 {
10838         struct aead_test_data tdata;
10839         int res;
10840
10841         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10842         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10843         tdata.plaintext.data[0] += 1;
10844         res = test_authenticated_decryption(&tdata);
10845         if (res == TEST_SKIPPED)
10846                 return res;
10847         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10848         return TEST_SUCCESS;
10849 }
10850
10851 static int
10852 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
10853 {
10854         struct aead_test_data tdata;
10855         int res;
10856
10857         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10858         tdata.ciphertext.data[0] += 1;
10859         res = test_authenticated_decryption(&tdata);
10860         if (res == TEST_SKIPPED)
10861                 return res;
10862         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10863         return TEST_SUCCESS;
10864 }
10865
10866 static int
10867 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
10868 {
10869         struct aead_test_data tdata;
10870         int res;
10871
10872         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10873         tdata.aad.len += 1;
10874         res = test_authenticated_decryption(&tdata);
10875         if (res == TEST_SKIPPED)
10876                 return res;
10877         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10878         return TEST_SUCCESS;
10879 }
10880
10881 static int
10882 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
10883 {
10884         struct aead_test_data tdata;
10885         uint8_t aad[gcm_test_case_7.aad.len];
10886         int res;
10887
10888         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10889         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10890         aad[0] += 1;
10891         tdata.aad.data = aad;
10892         res = test_authenticated_decryption(&tdata);
10893         if (res == TEST_SKIPPED)
10894                 return res;
10895         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
10896         return TEST_SUCCESS;
10897 }
10898
10899 static int
10900 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
10901 {
10902         struct aead_test_data tdata;
10903         int res;
10904
10905         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10906         tdata.auth_tag.data[0] += 1;
10907         res = test_authenticated_decryption(&tdata);
10908         if (res == TEST_SKIPPED)
10909                 return res;
10910         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
10911         return TEST_SUCCESS;
10912 }
10913
10914 static int
10915 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
10916 {
10917         struct crypto_testsuite_params *ts_params = &testsuite_params;
10918         struct crypto_unittest_params *ut_params = &unittest_params;
10919
10920         int retval;
10921         uint8_t *ciphertext, *auth_tag;
10922         uint16_t plaintext_pad_len;
10923         struct rte_cryptodev_info dev_info;
10924
10925         /* Verify the capabilities */
10926         struct rte_cryptodev_sym_capability_idx cap_idx;
10927         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10928         cap_idx.algo.aead = tdata->algo;
10929         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
10930                         &cap_idx) == NULL)
10931                 return TEST_SKIPPED;
10932
10933         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10934         uint64_t feat_flags = dev_info.feature_flags;
10935
10936         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10937                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
10938                 return TEST_SKIPPED;
10939
10940         /* not supported with CPU crypto */
10941         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10942                 return TEST_SKIPPED;
10943
10944         /* Create AEAD session */
10945         retval = create_aead_session(ts_params->valid_devs[0],
10946                         tdata->algo,
10947                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
10948                         tdata->key.data, tdata->key.len,
10949                         tdata->aad.len, tdata->auth_tag.len,
10950                         tdata->iv.len);
10951         if (retval < 0)
10952                 return retval;
10953
10954         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10955         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10956
10957         /* clear mbuf payload */
10958         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10959                         rte_pktmbuf_tailroom(ut_params->ibuf));
10960         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
10961                         rte_pktmbuf_tailroom(ut_params->obuf));
10962
10963         /* Create AEAD operation */
10964         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
10965         if (retval < 0)
10966                 return retval;
10967
10968         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10969
10970         ut_params->op->sym->m_src = ut_params->ibuf;
10971         ut_params->op->sym->m_dst = ut_params->obuf;
10972
10973         /* Process crypto operation */
10974         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10975                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10976                         ut_params->op, 0, 0, 0, 0);
10977         else
10978                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
10979                         ut_params->op), "failed to process sym crypto op");
10980
10981         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10982                         "crypto op processing failed");
10983
10984         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
10985
10986         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
10987                         ut_params->op->sym->cipher.data.offset);
10988         auth_tag = ciphertext + plaintext_pad_len;
10989
10990         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
10991         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
10992
10993         /* Validate obuf */
10994         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10995                         ciphertext,
10996                         tdata->ciphertext.data,
10997                         tdata->ciphertext.len,
10998                         "Ciphertext data not as expected");
10999
11000         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11001                         auth_tag,
11002                         tdata->auth_tag.data,
11003                         tdata->auth_tag.len,
11004                         "Generated auth tag not as expected");
11005
11006         return 0;
11007
11008 }
11009
11010 static int
11011 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
11012 {
11013         return test_authenticated_encryption_oop(&gcm_test_case_5);
11014 }
11015
11016 static int
11017 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
11018 {
11019         struct crypto_testsuite_params *ts_params = &testsuite_params;
11020         struct crypto_unittest_params *ut_params = &unittest_params;
11021
11022         int retval;
11023         uint8_t *plaintext;
11024         struct rte_cryptodev_info dev_info;
11025
11026         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11027         uint64_t feat_flags = dev_info.feature_flags;
11028
11029         /* Verify the capabilities */
11030         struct rte_cryptodev_sym_capability_idx cap_idx;
11031         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11032         cap_idx.algo.aead = tdata->algo;
11033         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11034                         &cap_idx) == NULL)
11035                 return TEST_SKIPPED;
11036
11037         /* not supported with CPU crypto and raw data-path APIs*/
11038         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
11039                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
11040                 return TEST_SKIPPED;
11041
11042         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11043                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11044                 printf("Device does not support RAW data-path APIs.\n");
11045                 return TEST_SKIPPED;
11046         }
11047
11048         /* Create AEAD session */
11049         retval = create_aead_session(ts_params->valid_devs[0],
11050                         tdata->algo,
11051                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11052                         tdata->key.data, tdata->key.len,
11053                         tdata->aad.len, tdata->auth_tag.len,
11054                         tdata->iv.len);
11055         if (retval < 0)
11056                 return retval;
11057
11058         /* alloc mbuf and set payload */
11059         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11060         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11061
11062         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11063                         rte_pktmbuf_tailroom(ut_params->ibuf));
11064         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11065                         rte_pktmbuf_tailroom(ut_params->obuf));
11066
11067         /* Create AEAD operation */
11068         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11069         if (retval < 0)
11070                 return retval;
11071
11072         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11073
11074         ut_params->op->sym->m_src = ut_params->ibuf;
11075         ut_params->op->sym->m_dst = ut_params->obuf;
11076
11077         /* Process crypto operation */
11078         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11079                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11080                                 ut_params->op, 0, 0, 0, 0);
11081         else
11082                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11083                         ut_params->op), "failed to process sym crypto op");
11084
11085         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11086                         "crypto op processing failed");
11087
11088         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11089                         ut_params->op->sym->cipher.data.offset);
11090
11091         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11092
11093         /* Validate obuf */
11094         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11095                         plaintext,
11096                         tdata->plaintext.data,
11097                         tdata->plaintext.len,
11098                         "Plaintext data not as expected");
11099
11100         TEST_ASSERT_EQUAL(ut_params->op->status,
11101                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11102                         "Authentication failed");
11103         return 0;
11104 }
11105
11106 static int
11107 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
11108 {
11109         return test_authenticated_decryption_oop(&gcm_test_case_5);
11110 }
11111
11112 static int
11113 test_authenticated_encryption_sessionless(
11114                 const struct aead_test_data *tdata)
11115 {
11116         struct crypto_testsuite_params *ts_params = &testsuite_params;
11117         struct crypto_unittest_params *ut_params = &unittest_params;
11118
11119         int retval;
11120         uint8_t *ciphertext, *auth_tag;
11121         uint16_t plaintext_pad_len;
11122         uint8_t key[tdata->key.len + 1];
11123         struct rte_cryptodev_info dev_info;
11124
11125         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11126         uint64_t feat_flags = dev_info.feature_flags;
11127
11128         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11129                 printf("Device doesn't support Sessionless ops.\n");
11130                 return TEST_SKIPPED;
11131         }
11132
11133         /* not supported with CPU crypto */
11134         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11135                 return TEST_SKIPPED;
11136
11137         /* Verify the capabilities */
11138         struct rte_cryptodev_sym_capability_idx cap_idx;
11139         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11140         cap_idx.algo.aead = tdata->algo;
11141         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11142                         &cap_idx) == NULL)
11143                 return TEST_SKIPPED;
11144
11145         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11146
11147         /* clear mbuf payload */
11148         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11149                         rte_pktmbuf_tailroom(ut_params->ibuf));
11150
11151         /* Create AEAD operation */
11152         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11153         if (retval < 0)
11154                 return retval;
11155
11156         /* Create GCM xform */
11157         memcpy(key, tdata->key.data, tdata->key.len);
11158         retval = create_aead_xform(ut_params->op,
11159                         tdata->algo,
11160                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11161                         key, tdata->key.len,
11162                         tdata->aad.len, tdata->auth_tag.len,
11163                         tdata->iv.len);
11164         if (retval < 0)
11165                 return retval;
11166
11167         ut_params->op->sym->m_src = ut_params->ibuf;
11168
11169         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11170                         RTE_CRYPTO_OP_SESSIONLESS,
11171                         "crypto op session type not sessionless");
11172
11173         /* Process crypto operation */
11174         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11175                         ut_params->op), "failed to process sym crypto op");
11176
11177         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11178
11179         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11180                         "crypto op status not success");
11181
11182         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11183
11184         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11185                         ut_params->op->sym->cipher.data.offset);
11186         auth_tag = ciphertext + plaintext_pad_len;
11187
11188         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11189         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11190
11191         /* Validate obuf */
11192         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11193                         ciphertext,
11194                         tdata->ciphertext.data,
11195                         tdata->ciphertext.len,
11196                         "Ciphertext data not as expected");
11197
11198         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11199                         auth_tag,
11200                         tdata->auth_tag.data,
11201                         tdata->auth_tag.len,
11202                         "Generated auth tag not as expected");
11203
11204         return 0;
11205
11206 }
11207
11208 static int
11209 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11210 {
11211         return test_authenticated_encryption_sessionless(
11212                         &gcm_test_case_5);
11213 }
11214
11215 static int
11216 test_authenticated_decryption_sessionless(
11217                 const struct aead_test_data *tdata)
11218 {
11219         struct crypto_testsuite_params *ts_params = &testsuite_params;
11220         struct crypto_unittest_params *ut_params = &unittest_params;
11221
11222         int retval;
11223         uint8_t *plaintext;
11224         uint8_t key[tdata->key.len + 1];
11225         struct rte_cryptodev_info dev_info;
11226
11227         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11228         uint64_t feat_flags = dev_info.feature_flags;
11229
11230         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11231                 printf("Device doesn't support Sessionless ops.\n");
11232                 return TEST_SKIPPED;
11233         }
11234
11235         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11236                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11237                 printf("Device doesn't support RAW data-path APIs.\n");
11238                 return TEST_SKIPPED;
11239         }
11240
11241         /* not supported with CPU crypto */
11242         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11243                 return TEST_SKIPPED;
11244
11245         /* Verify the capabilities */
11246         struct rte_cryptodev_sym_capability_idx cap_idx;
11247         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11248         cap_idx.algo.aead = tdata->algo;
11249         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11250                         &cap_idx) == NULL)
11251                 return TEST_SKIPPED;
11252
11253         /* alloc mbuf and set payload */
11254         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11255
11256         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11257                         rte_pktmbuf_tailroom(ut_params->ibuf));
11258
11259         /* Create AEAD operation */
11260         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11261         if (retval < 0)
11262                 return retval;
11263
11264         /* Create AEAD xform */
11265         memcpy(key, tdata->key.data, tdata->key.len);
11266         retval = create_aead_xform(ut_params->op,
11267                         tdata->algo,
11268                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11269                         key, tdata->key.len,
11270                         tdata->aad.len, tdata->auth_tag.len,
11271                         tdata->iv.len);
11272         if (retval < 0)
11273                 return retval;
11274
11275         ut_params->op->sym->m_src = ut_params->ibuf;
11276
11277         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11278                         RTE_CRYPTO_OP_SESSIONLESS,
11279                         "crypto op session type not sessionless");
11280
11281         /* Process crypto operation */
11282         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11283                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11284                                 ut_params->op, 0, 0, 0, 0);
11285         else
11286                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11287                         ts_params->valid_devs[0], ut_params->op),
11288                                 "failed to process sym crypto op");
11289
11290         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11291
11292         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11293                         "crypto op status not success");
11294
11295         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11296                         ut_params->op->sym->cipher.data.offset);
11297
11298         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11299
11300         /* Validate obuf */
11301         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11302                         plaintext,
11303                         tdata->plaintext.data,
11304                         tdata->plaintext.len,
11305                         "Plaintext data not as expected");
11306
11307         TEST_ASSERT_EQUAL(ut_params->op->status,
11308                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11309                         "Authentication failed");
11310         return 0;
11311 }
11312
11313 static int
11314 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11315 {
11316         return test_authenticated_decryption_sessionless(
11317                         &gcm_test_case_5);
11318 }
11319
11320 static int
11321 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11322 {
11323         return test_authenticated_encryption(&ccm_test_case_128_1);
11324 }
11325
11326 static int
11327 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11328 {
11329         return test_authenticated_encryption(&ccm_test_case_128_2);
11330 }
11331
11332 static int
11333 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11334 {
11335         return test_authenticated_encryption(&ccm_test_case_128_3);
11336 }
11337
11338 static int
11339 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11340 {
11341         return test_authenticated_decryption(&ccm_test_case_128_1);
11342 }
11343
11344 static int
11345 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11346 {
11347         return test_authenticated_decryption(&ccm_test_case_128_2);
11348 }
11349
11350 static int
11351 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11352 {
11353         return test_authenticated_decryption(&ccm_test_case_128_3);
11354 }
11355
11356 static int
11357 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11358 {
11359         return test_authenticated_encryption(&ccm_test_case_192_1);
11360 }
11361
11362 static int
11363 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11364 {
11365         return test_authenticated_encryption(&ccm_test_case_192_2);
11366 }
11367
11368 static int
11369 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11370 {
11371         return test_authenticated_encryption(&ccm_test_case_192_3);
11372 }
11373
11374 static int
11375 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11376 {
11377         return test_authenticated_decryption(&ccm_test_case_192_1);
11378 }
11379
11380 static int
11381 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11382 {
11383         return test_authenticated_decryption(&ccm_test_case_192_2);
11384 }
11385
11386 static int
11387 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11388 {
11389         return test_authenticated_decryption(&ccm_test_case_192_3);
11390 }
11391
11392 static int
11393 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11394 {
11395         return test_authenticated_encryption(&ccm_test_case_256_1);
11396 }
11397
11398 static int
11399 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11400 {
11401         return test_authenticated_encryption(&ccm_test_case_256_2);
11402 }
11403
11404 static int
11405 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11406 {
11407         return test_authenticated_encryption(&ccm_test_case_256_3);
11408 }
11409
11410 static int
11411 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11412 {
11413         return test_authenticated_decryption(&ccm_test_case_256_1);
11414 }
11415
11416 static int
11417 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11418 {
11419         return test_authenticated_decryption(&ccm_test_case_256_2);
11420 }
11421
11422 static int
11423 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11424 {
11425         return test_authenticated_decryption(&ccm_test_case_256_3);
11426 }
11427
11428 static int
11429 test_stats(void)
11430 {
11431         struct crypto_testsuite_params *ts_params = &testsuite_params;
11432         struct rte_cryptodev_stats stats;
11433
11434         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11435                 return TEST_SKIPPED;
11436
11437         /* Verify the capabilities */
11438         struct rte_cryptodev_sym_capability_idx cap_idx;
11439         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11440         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11441         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11442                         &cap_idx) == NULL)
11443                 return TEST_SKIPPED;
11444         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11445         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11446         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11447                         &cap_idx) == NULL)
11448                 return TEST_SKIPPED;
11449
11450         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11451                         == -ENOTSUP)
11452                 return TEST_SKIPPED;
11453
11454         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11455         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11456                         &stats) == -ENODEV),
11457                 "rte_cryptodev_stats_get invalid dev failed");
11458         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11459                 "rte_cryptodev_stats_get invalid Param failed");
11460
11461         /* Test expected values */
11462         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11463         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11464                         &stats),
11465                 "rte_cryptodev_stats_get failed");
11466         TEST_ASSERT((stats.enqueued_count == 1),
11467                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11468         TEST_ASSERT((stats.dequeued_count == 1),
11469                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11470         TEST_ASSERT((stats.enqueue_err_count == 0),
11471                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11472         TEST_ASSERT((stats.dequeue_err_count == 0),
11473                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11474
11475         /* invalid device but should ignore and not reset device stats*/
11476         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11477         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11478                         &stats),
11479                 "rte_cryptodev_stats_get failed");
11480         TEST_ASSERT((stats.enqueued_count == 1),
11481                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11482
11483         /* check that a valid reset clears stats */
11484         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11485         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11486                         &stats),
11487                                           "rte_cryptodev_stats_get failed");
11488         TEST_ASSERT((stats.enqueued_count == 0),
11489                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11490         TEST_ASSERT((stats.dequeued_count == 0),
11491                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11492
11493         return TEST_SUCCESS;
11494 }
11495
11496 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11497                                    struct crypto_unittest_params *ut_params,
11498                                    enum rte_crypto_auth_operation op,
11499                                    const struct HMAC_MD5_vector *test_case)
11500 {
11501         uint8_t key[64];
11502         int status;
11503
11504         memcpy(key, test_case->key.data, test_case->key.len);
11505
11506         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11507         ut_params->auth_xform.next = NULL;
11508         ut_params->auth_xform.auth.op = op;
11509
11510         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11511
11512         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11513         ut_params->auth_xform.auth.key.length = test_case->key.len;
11514         ut_params->auth_xform.auth.key.data = key;
11515
11516         ut_params->sess = rte_cryptodev_sym_session_create(
11517                         ts_params->session_mpool);
11518         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11519         if (ut_params->sess == NULL)
11520                 return TEST_FAILED;
11521
11522         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11523                         ut_params->sess, &ut_params->auth_xform,
11524                         ts_params->session_priv_mpool);
11525         if (status == -ENOTSUP)
11526                 return TEST_SKIPPED;
11527
11528         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11529
11530         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11531                         rte_pktmbuf_tailroom(ut_params->ibuf));
11532
11533         return 0;
11534 }
11535
11536 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11537                               const struct HMAC_MD5_vector *test_case,
11538                               uint8_t **plaintext)
11539 {
11540         uint16_t plaintext_pad_len;
11541
11542         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11543
11544         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11545                                 16);
11546
11547         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11548                         plaintext_pad_len);
11549         memcpy(*plaintext, test_case->plaintext.data,
11550                         test_case->plaintext.len);
11551
11552         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11553                         ut_params->ibuf, MD5_DIGEST_LEN);
11554         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11555                         "no room to append digest");
11556         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11557                         ut_params->ibuf, plaintext_pad_len);
11558
11559         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11560                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11561                            test_case->auth_tag.len);
11562         }
11563
11564         sym_op->auth.data.offset = 0;
11565         sym_op->auth.data.length = test_case->plaintext.len;
11566
11567         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11568         ut_params->op->sym->m_src = ut_params->ibuf;
11569
11570         return 0;
11571 }
11572
11573 static int
11574 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11575 {
11576         uint16_t plaintext_pad_len;
11577         uint8_t *plaintext, *auth_tag;
11578
11579         struct crypto_testsuite_params *ts_params = &testsuite_params;
11580         struct crypto_unittest_params *ut_params = &unittest_params;
11581         struct rte_cryptodev_info dev_info;
11582
11583         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11584         uint64_t feat_flags = dev_info.feature_flags;
11585
11586         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11587                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11588                 printf("Device doesn't support RAW data-path APIs.\n");
11589                 return TEST_SKIPPED;
11590         }
11591
11592         /* Verify the capabilities */
11593         struct rte_cryptodev_sym_capability_idx cap_idx;
11594         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11595         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11596         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11597                         &cap_idx) == NULL)
11598                 return TEST_SKIPPED;
11599
11600         if (MD5_HMAC_create_session(ts_params, ut_params,
11601                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11602                 return TEST_FAILED;
11603
11604         /* Generate Crypto op data structure */
11605         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11606                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11607         TEST_ASSERT_NOT_NULL(ut_params->op,
11608                         "Failed to allocate symmetric crypto operation struct");
11609
11610         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11611                                 16);
11612
11613         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11614                 return TEST_FAILED;
11615
11616         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11617                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11618                         ut_params->op);
11619         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11620                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11621                                 ut_params->op, 0, 1, 0, 0);
11622         else
11623                 TEST_ASSERT_NOT_NULL(
11624                         process_crypto_request(ts_params->valid_devs[0],
11625                                 ut_params->op),
11626                                 "failed to process sym crypto op");
11627
11628         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11629                         "crypto op processing failed");
11630
11631         if (ut_params->op->sym->m_dst) {
11632                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11633                                 uint8_t *, plaintext_pad_len);
11634         } else {
11635                 auth_tag = plaintext + plaintext_pad_len;
11636         }
11637
11638         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11639                         auth_tag,
11640                         test_case->auth_tag.data,
11641                         test_case->auth_tag.len,
11642                         "HMAC_MD5 generated tag not as expected");
11643
11644         return TEST_SUCCESS;
11645 }
11646
11647 static int
11648 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11649 {
11650         uint8_t *plaintext;
11651
11652         struct crypto_testsuite_params *ts_params = &testsuite_params;
11653         struct crypto_unittest_params *ut_params = &unittest_params;
11654         struct rte_cryptodev_info dev_info;
11655
11656         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11657         uint64_t feat_flags = dev_info.feature_flags;
11658
11659         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11660                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11661                 printf("Device doesn't support RAW data-path APIs.\n");
11662                 return TEST_SKIPPED;
11663         }
11664
11665         /* Verify the capabilities */
11666         struct rte_cryptodev_sym_capability_idx cap_idx;
11667         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11668         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11669         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11670                         &cap_idx) == NULL)
11671                 return TEST_SKIPPED;
11672
11673         if (MD5_HMAC_create_session(ts_params, ut_params,
11674                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11675                 return TEST_FAILED;
11676         }
11677
11678         /* Generate Crypto op data structure */
11679         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11680                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11681         TEST_ASSERT_NOT_NULL(ut_params->op,
11682                         "Failed to allocate symmetric crypto operation struct");
11683
11684         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11685                 return TEST_FAILED;
11686
11687         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11688                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11689                         ut_params->op);
11690         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11691                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11692                                 ut_params->op, 0, 1, 0, 0);
11693         else
11694                 TEST_ASSERT_NOT_NULL(
11695                         process_crypto_request(ts_params->valid_devs[0],
11696                                 ut_params->op),
11697                                 "failed to process sym crypto op");
11698
11699         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11700                         "HMAC_MD5 crypto op processing failed");
11701
11702         return TEST_SUCCESS;
11703 }
11704
11705 static int
11706 test_MD5_HMAC_generate_case_1(void)
11707 {
11708         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11709 }
11710
11711 static int
11712 test_MD5_HMAC_verify_case_1(void)
11713 {
11714         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11715 }
11716
11717 static int
11718 test_MD5_HMAC_generate_case_2(void)
11719 {
11720         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11721 }
11722
11723 static int
11724 test_MD5_HMAC_verify_case_2(void)
11725 {
11726         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
11727 }
11728
11729 static int
11730 test_multi_session(void)
11731 {
11732         struct crypto_testsuite_params *ts_params = &testsuite_params;
11733         struct crypto_unittest_params *ut_params = &unittest_params;
11734
11735         struct rte_cryptodev_info dev_info;
11736         struct rte_cryptodev_sym_session **sessions;
11737
11738         uint16_t i;
11739         int status;
11740
11741         /* Verify the capabilities */
11742         struct rte_cryptodev_sym_capability_idx cap_idx;
11743         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11744         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11745         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11746                         &cap_idx) == NULL)
11747                 return TEST_SKIPPED;
11748         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11749         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11750         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11751                         &cap_idx) == NULL)
11752                 return TEST_SKIPPED;
11753
11754         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
11755                         aes_cbc_key, hmac_sha512_key);
11756
11757
11758         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11759
11760         sessions = rte_malloc(NULL,
11761                         sizeof(struct rte_cryptodev_sym_session *) *
11762                         (MAX_NB_SESSIONS + 1), 0);
11763
11764         /* Create multiple crypto sessions*/
11765         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11766
11767                 sessions[i] = rte_cryptodev_sym_session_create(
11768                                 ts_params->session_mpool);
11769                 TEST_ASSERT_NOT_NULL(sessions[i],
11770                                 "Session creation failed at session number %u",
11771                                 i);
11772
11773                 status = rte_cryptodev_sym_session_init(
11774                                 ts_params->valid_devs[0],
11775                                 sessions[i], &ut_params->auth_xform,
11776                                 ts_params->session_priv_mpool);
11777                 if (status == -ENOTSUP)
11778                         return TEST_SKIPPED;
11779
11780                 /* Attempt to send a request on each session */
11781                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
11782                         sessions[i],
11783                         ut_params,
11784                         ts_params,
11785                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
11786                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
11787                         aes_cbc_iv),
11788                         "Failed to perform decrypt on request number %u.", i);
11789                 /* free crypto operation structure */
11790                 if (ut_params->op)
11791                         rte_crypto_op_free(ut_params->op);
11792
11793                 /*
11794                  * free mbuf - both obuf and ibuf are usually the same,
11795                  * so check if they point at the same address is necessary,
11796                  * to avoid freeing the mbuf twice.
11797                  */
11798                 if (ut_params->obuf) {
11799                         rte_pktmbuf_free(ut_params->obuf);
11800                         if (ut_params->ibuf == ut_params->obuf)
11801                                 ut_params->ibuf = 0;
11802                         ut_params->obuf = 0;
11803                 }
11804                 if (ut_params->ibuf) {
11805                         rte_pktmbuf_free(ut_params->ibuf);
11806                         ut_params->ibuf = 0;
11807                 }
11808         }
11809
11810         sessions[i] = NULL;
11811         /* Next session create should fail */
11812         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11813                         sessions[i], &ut_params->auth_xform,
11814                         ts_params->session_priv_mpool);
11815         TEST_ASSERT_NULL(sessions[i],
11816                         "Session creation succeeded unexpectedly!");
11817
11818         for (i = 0; i < MAX_NB_SESSIONS; i++) {
11819                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11820                                 sessions[i]);
11821                 rte_cryptodev_sym_session_free(sessions[i]);
11822         }
11823
11824         rte_free(sessions);
11825
11826         return TEST_SUCCESS;
11827 }
11828
11829 struct multi_session_params {
11830         struct crypto_unittest_params ut_params;
11831         uint8_t *cipher_key;
11832         uint8_t *hmac_key;
11833         const uint8_t *cipher;
11834         const uint8_t *digest;
11835         uint8_t *iv;
11836 };
11837
11838 #define MB_SESSION_NUMBER 3
11839
11840 static int
11841 test_multi_session_random_usage(void)
11842 {
11843         struct crypto_testsuite_params *ts_params = &testsuite_params;
11844         struct rte_cryptodev_info dev_info;
11845         struct rte_cryptodev_sym_session **sessions;
11846         uint32_t i, j;
11847         struct multi_session_params ut_paramz[] = {
11848
11849                 {
11850                         .cipher_key = ms_aes_cbc_key0,
11851                         .hmac_key = ms_hmac_key0,
11852                         .cipher = ms_aes_cbc_cipher0,
11853                         .digest = ms_hmac_digest0,
11854                         .iv = ms_aes_cbc_iv0
11855                 },
11856                 {
11857                         .cipher_key = ms_aes_cbc_key1,
11858                         .hmac_key = ms_hmac_key1,
11859                         .cipher = ms_aes_cbc_cipher1,
11860                         .digest = ms_hmac_digest1,
11861                         .iv = ms_aes_cbc_iv1
11862                 },
11863                 {
11864                         .cipher_key = ms_aes_cbc_key2,
11865                         .hmac_key = ms_hmac_key2,
11866                         .cipher = ms_aes_cbc_cipher2,
11867                         .digest = ms_hmac_digest2,
11868                         .iv = ms_aes_cbc_iv2
11869                 },
11870
11871         };
11872         int status;
11873
11874         /* Verify the capabilities */
11875         struct rte_cryptodev_sym_capability_idx cap_idx;
11876         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11877         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
11878         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11879                         &cap_idx) == NULL)
11880                 return TEST_SKIPPED;
11881         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11882         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11883         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11884                         &cap_idx) == NULL)
11885                 return TEST_SKIPPED;
11886
11887         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11888
11889         sessions = rte_malloc(NULL,
11890                         (sizeof(struct rte_cryptodev_sym_session *)
11891                                         * MAX_NB_SESSIONS) + 1, 0);
11892
11893         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11894                 sessions[i] = rte_cryptodev_sym_session_create(
11895                                 ts_params->session_mpool);
11896                 TEST_ASSERT_NOT_NULL(sessions[i],
11897                                 "Session creation failed at session number %u",
11898                                 i);
11899
11900                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
11901                                 sizeof(struct crypto_unittest_params));
11902
11903                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
11904                                 &ut_paramz[i].ut_params,
11905                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
11906
11907                 /* Create multiple crypto sessions*/
11908                 status = rte_cryptodev_sym_session_init(
11909                                 ts_params->valid_devs[0],
11910                                 sessions[i],
11911                                 &ut_paramz[i].ut_params.auth_xform,
11912                                 ts_params->session_priv_mpool);
11913
11914                 if (status == -ENOTSUP)
11915                         return TEST_SKIPPED;
11916
11917                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
11918         }
11919
11920         srand(time(NULL));
11921         for (i = 0; i < 40000; i++) {
11922
11923                 j = rand() % MB_SESSION_NUMBER;
11924
11925                 TEST_ASSERT_SUCCESS(
11926                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
11927                                         sessions[j],
11928                                         &ut_paramz[j].ut_params,
11929                                         ts_params, ut_paramz[j].cipher,
11930                                         ut_paramz[j].digest,
11931                                         ut_paramz[j].iv),
11932                         "Failed to perform decrypt on request number %u.", i);
11933
11934                 if (ut_paramz[j].ut_params.op)
11935                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
11936
11937                 /*
11938                  * free mbuf - both obuf and ibuf are usually the same,
11939                  * so check if they point at the same address is necessary,
11940                  * to avoid freeing the mbuf twice.
11941                  */
11942                 if (ut_paramz[j].ut_params.obuf) {
11943                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
11944                         if (ut_paramz[j].ut_params.ibuf
11945                                         == ut_paramz[j].ut_params.obuf)
11946                                 ut_paramz[j].ut_params.ibuf = 0;
11947                         ut_paramz[j].ut_params.obuf = 0;
11948                 }
11949                 if (ut_paramz[j].ut_params.ibuf) {
11950                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
11951                         ut_paramz[j].ut_params.ibuf = 0;
11952                 }
11953         }
11954
11955         for (i = 0; i < MB_SESSION_NUMBER; i++) {
11956                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
11957                                 sessions[i]);
11958                 rte_cryptodev_sym_session_free(sessions[i]);
11959         }
11960
11961         rte_free(sessions);
11962
11963         return TEST_SUCCESS;
11964 }
11965
11966 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
11967                         0xab, 0xab, 0xab, 0xab,
11968                         0xab, 0xab, 0xab, 0xab,
11969                         0xab, 0xab, 0xab, 0xab};
11970
11971 static int
11972 test_null_invalid_operation(void)
11973 {
11974         struct crypto_testsuite_params *ts_params = &testsuite_params;
11975         struct crypto_unittest_params *ut_params = &unittest_params;
11976         int ret;
11977
11978         /* This test is for NULL PMD only */
11979         if (gbl_driver_id != rte_cryptodev_driver_id_get(
11980                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
11981                 return TEST_SKIPPED;
11982
11983         /* Setup Cipher Parameters */
11984         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11985         ut_params->cipher_xform.next = NULL;
11986
11987         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
11988         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
11989
11990         ut_params->sess = rte_cryptodev_sym_session_create(
11991                         ts_params->session_mpool);
11992
11993         /* Create Crypto session*/
11994         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11995                         ut_params->sess, &ut_params->cipher_xform,
11996                         ts_params->session_priv_mpool);
11997         TEST_ASSERT(ret < 0,
11998                         "Session creation succeeded unexpectedly");
11999
12000
12001         /* Setup HMAC Parameters */
12002         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12003         ut_params->auth_xform.next = NULL;
12004
12005         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
12006         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12007
12008         ut_params->sess = rte_cryptodev_sym_session_create(
12009                         ts_params->session_mpool);
12010
12011         /* Create Crypto session*/
12012         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12013                         ut_params->sess, &ut_params->auth_xform,
12014                         ts_params->session_priv_mpool);
12015         TEST_ASSERT(ret < 0,
12016                         "Session creation succeeded unexpectedly");
12017
12018         return TEST_SUCCESS;
12019 }
12020
12021
12022 #define NULL_BURST_LENGTH (32)
12023
12024 static int
12025 test_null_burst_operation(void)
12026 {
12027         struct crypto_testsuite_params *ts_params = &testsuite_params;
12028         struct crypto_unittest_params *ut_params = &unittest_params;
12029         int status;
12030
12031         unsigned i, burst_len = NULL_BURST_LENGTH;
12032
12033         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
12034         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
12035
12036         /* This test is for NULL PMD only */
12037         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12038                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12039                 return TEST_SKIPPED;
12040
12041         /* Setup Cipher Parameters */
12042         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12043         ut_params->cipher_xform.next = &ut_params->auth_xform;
12044
12045         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
12046         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12047
12048         /* Setup HMAC Parameters */
12049         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12050         ut_params->auth_xform.next = NULL;
12051
12052         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
12053         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12054
12055         ut_params->sess = rte_cryptodev_sym_session_create(
12056                         ts_params->session_mpool);
12057         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12058
12059         /* Create Crypto session*/
12060         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12061                         ut_params->sess, &ut_params->cipher_xform,
12062                         ts_params->session_priv_mpool);
12063
12064         if (status == -ENOTSUP)
12065                 return TEST_SKIPPED;
12066
12067         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12068
12069         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
12070                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
12071                         burst_len, "failed to generate burst of crypto ops");
12072
12073         /* Generate an operation for each mbuf in burst */
12074         for (i = 0; i < burst_len; i++) {
12075                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12076
12077                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
12078
12079                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
12080                                 sizeof(unsigned));
12081                 *data = i;
12082
12083                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
12084
12085                 burst[i]->sym->m_src = m;
12086         }
12087
12088         /* Process crypto operation */
12089         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
12090                         0, burst, burst_len),
12091                         burst_len,
12092                         "Error enqueuing burst");
12093
12094         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
12095                         0, burst_dequeued, burst_len),
12096                         burst_len,
12097                         "Error dequeuing burst");
12098
12099
12100         for (i = 0; i < burst_len; i++) {
12101                 TEST_ASSERT_EQUAL(
12102                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
12103                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
12104                                         uint32_t *),
12105                         "data not as expected");
12106
12107                 rte_pktmbuf_free(burst[i]->sym->m_src);
12108                 rte_crypto_op_free(burst[i]);
12109         }
12110
12111         return TEST_SUCCESS;
12112 }
12113
12114 static uint16_t
12115 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12116                   uint16_t nb_ops, void *user_param)
12117 {
12118         RTE_SET_USED(dev_id);
12119         RTE_SET_USED(qp_id);
12120         RTE_SET_USED(ops);
12121         RTE_SET_USED(user_param);
12122
12123         printf("crypto enqueue callback called\n");
12124         return nb_ops;
12125 }
12126
12127 static uint16_t
12128 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12129                   uint16_t nb_ops, void *user_param)
12130 {
12131         RTE_SET_USED(dev_id);
12132         RTE_SET_USED(qp_id);
12133         RTE_SET_USED(ops);
12134         RTE_SET_USED(user_param);
12135
12136         printf("crypto dequeue callback called\n");
12137         return nb_ops;
12138 }
12139
12140 /*
12141  * Thread using enqueue/dequeue callback with RCU.
12142  */
12143 static int
12144 test_enqdeq_callback_thread(void *arg)
12145 {
12146         RTE_SET_USED(arg);
12147         /* DP thread calls rte_cryptodev_enqueue_burst()/
12148          * rte_cryptodev_dequeue_burst() and invokes callback.
12149          */
12150         test_null_burst_operation();
12151         return 0;
12152 }
12153
12154 static int
12155 test_enq_callback_setup(void)
12156 {
12157         struct crypto_testsuite_params *ts_params = &testsuite_params;
12158         struct rte_cryptodev_info dev_info;
12159         struct rte_cryptodev_qp_conf qp_conf = {
12160                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12161         };
12162
12163         struct rte_cryptodev_cb *cb;
12164         uint16_t qp_id = 0;
12165
12166         /* Stop the device in case it's started so it can be configured */
12167         rte_cryptodev_stop(ts_params->valid_devs[0]);
12168
12169         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12170
12171         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12172                         &ts_params->conf),
12173                         "Failed to configure cryptodev %u",
12174                         ts_params->valid_devs[0]);
12175
12176         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12177         qp_conf.mp_session = ts_params->session_mpool;
12178         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12179
12180         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12181                         ts_params->valid_devs[0], qp_id, &qp_conf,
12182                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12183                         "Failed test for "
12184                         "rte_cryptodev_queue_pair_setup: num_inflights "
12185                         "%u on qp %u on cryptodev %u",
12186                         qp_conf.nb_descriptors, qp_id,
12187                         ts_params->valid_devs[0]);
12188
12189         /* Test with invalid crypto device */
12190         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
12191                         qp_id, test_enq_callback, NULL);
12192         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12193                         "cryptodev %u did not fail",
12194                         qp_id, RTE_CRYPTO_MAX_DEVS);
12195
12196         /* Test with invalid queue pair */
12197         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12198                         dev_info.max_nb_queue_pairs + 1,
12199                         test_enq_callback, NULL);
12200         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12201                         "cryptodev %u did not fail",
12202                         dev_info.max_nb_queue_pairs + 1,
12203                         ts_params->valid_devs[0]);
12204
12205         /* Test with NULL callback */
12206         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12207                         qp_id, NULL, NULL);
12208         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12209                         "cryptodev %u did not fail",
12210                         qp_id, ts_params->valid_devs[0]);
12211
12212         /* Test with valid configuration */
12213         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12214                         qp_id, test_enq_callback, NULL);
12215         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12216                         "qp %u on cryptodev %u",
12217                         qp_id, ts_params->valid_devs[0]);
12218
12219         rte_cryptodev_start(ts_params->valid_devs[0]);
12220
12221         /* Launch a thread */
12222         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12223                                 rte_get_next_lcore(-1, 1, 0));
12224
12225         /* Wait until reader exited. */
12226         rte_eal_mp_wait_lcore();
12227
12228         /* Test with invalid crypto device */
12229         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12230                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12231                         "Expected call to fail as crypto device is invalid");
12232
12233         /* Test with invalid queue pair */
12234         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12235                         ts_params->valid_devs[0],
12236                         dev_info.max_nb_queue_pairs + 1, cb),
12237                         "Expected call to fail as queue pair is invalid");
12238
12239         /* Test with NULL callback */
12240         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12241                         ts_params->valid_devs[0], qp_id, NULL),
12242                         "Expected call to fail as callback is NULL");
12243
12244         /* Test with valid configuration */
12245         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12246                         ts_params->valid_devs[0], qp_id, cb),
12247                         "Failed test to remove callback on "
12248                         "qp %u on cryptodev %u",
12249                         qp_id, ts_params->valid_devs[0]);
12250
12251         return TEST_SUCCESS;
12252 }
12253
12254 static int
12255 test_deq_callback_setup(void)
12256 {
12257         struct crypto_testsuite_params *ts_params = &testsuite_params;
12258         struct rte_cryptodev_info dev_info;
12259         struct rte_cryptodev_qp_conf qp_conf = {
12260                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12261         };
12262
12263         struct rte_cryptodev_cb *cb;
12264         uint16_t qp_id = 0;
12265
12266         /* Stop the device in case it's started so it can be configured */
12267         rte_cryptodev_stop(ts_params->valid_devs[0]);
12268
12269         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12270
12271         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12272                         &ts_params->conf),
12273                         "Failed to configure cryptodev %u",
12274                         ts_params->valid_devs[0]);
12275
12276         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12277         qp_conf.mp_session = ts_params->session_mpool;
12278         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12279
12280         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12281                         ts_params->valid_devs[0], qp_id, &qp_conf,
12282                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12283                         "Failed test for "
12284                         "rte_cryptodev_queue_pair_setup: num_inflights "
12285                         "%u on qp %u on cryptodev %u",
12286                         qp_conf.nb_descriptors, qp_id,
12287                         ts_params->valid_devs[0]);
12288
12289         /* Test with invalid crypto device */
12290         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12291                         qp_id, test_deq_callback, NULL);
12292         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12293                         "cryptodev %u did not fail",
12294                         qp_id, RTE_CRYPTO_MAX_DEVS);
12295
12296         /* Test with invalid queue pair */
12297         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12298                         dev_info.max_nb_queue_pairs + 1,
12299                         test_deq_callback, NULL);
12300         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12301                         "cryptodev %u did not fail",
12302                         dev_info.max_nb_queue_pairs + 1,
12303                         ts_params->valid_devs[0]);
12304
12305         /* Test with NULL callback */
12306         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12307                         qp_id, NULL, NULL);
12308         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12309                         "cryptodev %u did not fail",
12310                         qp_id, ts_params->valid_devs[0]);
12311
12312         /* Test with valid configuration */
12313         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12314                         qp_id, test_deq_callback, NULL);
12315         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12316                         "qp %u on cryptodev %u",
12317                         qp_id, ts_params->valid_devs[0]);
12318
12319         rte_cryptodev_start(ts_params->valid_devs[0]);
12320
12321         /* Launch a thread */
12322         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12323                                 rte_get_next_lcore(-1, 1, 0));
12324
12325         /* Wait until reader exited. */
12326         rte_eal_mp_wait_lcore();
12327
12328         /* Test with invalid crypto device */
12329         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12330                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12331                         "Expected call to fail as crypto device is invalid");
12332
12333         /* Test with invalid queue pair */
12334         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12335                         ts_params->valid_devs[0],
12336                         dev_info.max_nb_queue_pairs + 1, cb),
12337                         "Expected call to fail as queue pair is invalid");
12338
12339         /* Test with NULL callback */
12340         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12341                         ts_params->valid_devs[0], qp_id, NULL),
12342                         "Expected call to fail as callback is NULL");
12343
12344         /* Test with valid configuration */
12345         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12346                         ts_params->valid_devs[0], qp_id, cb),
12347                         "Failed test to remove callback on "
12348                         "qp %u on cryptodev %u",
12349                         qp_id, ts_params->valid_devs[0]);
12350
12351         return TEST_SUCCESS;
12352 }
12353
12354 static void
12355 generate_gmac_large_plaintext(uint8_t *data)
12356 {
12357         uint16_t i;
12358
12359         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12360                 memcpy(&data[i], &data[0], 32);
12361 }
12362
12363 static int
12364 create_gmac_operation(enum rte_crypto_auth_operation op,
12365                 const struct gmac_test_data *tdata)
12366 {
12367         struct crypto_testsuite_params *ts_params = &testsuite_params;
12368         struct crypto_unittest_params *ut_params = &unittest_params;
12369         struct rte_crypto_sym_op *sym_op;
12370
12371         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12372
12373         /* Generate Crypto op data structure */
12374         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12375                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12376         TEST_ASSERT_NOT_NULL(ut_params->op,
12377                         "Failed to allocate symmetric crypto operation struct");
12378
12379         sym_op = ut_params->op->sym;
12380
12381         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12382                         ut_params->ibuf, tdata->gmac_tag.len);
12383         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12384                         "no room to append digest");
12385
12386         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12387                         ut_params->ibuf, plaintext_pad_len);
12388
12389         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12390                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12391                                 tdata->gmac_tag.len);
12392                 debug_hexdump(stdout, "digest:",
12393                                 sym_op->auth.digest.data,
12394                                 tdata->gmac_tag.len);
12395         }
12396
12397         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12398                         uint8_t *, IV_OFFSET);
12399
12400         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12401
12402         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12403
12404         sym_op->cipher.data.length = 0;
12405         sym_op->cipher.data.offset = 0;
12406
12407         sym_op->auth.data.offset = 0;
12408         sym_op->auth.data.length = tdata->plaintext.len;
12409
12410         return 0;
12411 }
12412
12413 static int
12414 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12415                 const struct gmac_test_data *tdata,
12416                 void *digest_mem, uint64_t digest_phys)
12417 {
12418         struct crypto_testsuite_params *ts_params = &testsuite_params;
12419         struct crypto_unittest_params *ut_params = &unittest_params;
12420         struct rte_crypto_sym_op *sym_op;
12421
12422         /* Generate Crypto op data structure */
12423         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12424                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12425         TEST_ASSERT_NOT_NULL(ut_params->op,
12426                         "Failed to allocate symmetric crypto operation struct");
12427
12428         sym_op = ut_params->op->sym;
12429
12430         sym_op->auth.digest.data = digest_mem;
12431         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12432                         "no room to append digest");
12433
12434         sym_op->auth.digest.phys_addr = digest_phys;
12435
12436         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12437                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12438                                 tdata->gmac_tag.len);
12439                 debug_hexdump(stdout, "digest:",
12440                                 sym_op->auth.digest.data,
12441                                 tdata->gmac_tag.len);
12442         }
12443
12444         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12445                         uint8_t *, IV_OFFSET);
12446
12447         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12448
12449         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12450
12451         sym_op->cipher.data.length = 0;
12452         sym_op->cipher.data.offset = 0;
12453
12454         sym_op->auth.data.offset = 0;
12455         sym_op->auth.data.length = tdata->plaintext.len;
12456
12457         return 0;
12458 }
12459
12460 static int create_gmac_session(uint8_t dev_id,
12461                 const struct gmac_test_data *tdata,
12462                 enum rte_crypto_auth_operation auth_op)
12463 {
12464         uint8_t auth_key[tdata->key.len];
12465         int status;
12466
12467         struct crypto_testsuite_params *ts_params = &testsuite_params;
12468         struct crypto_unittest_params *ut_params = &unittest_params;
12469
12470         memcpy(auth_key, tdata->key.data, tdata->key.len);
12471
12472         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12473         ut_params->auth_xform.next = NULL;
12474
12475         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12476         ut_params->auth_xform.auth.op = auth_op;
12477         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12478         ut_params->auth_xform.auth.key.length = tdata->key.len;
12479         ut_params->auth_xform.auth.key.data = auth_key;
12480         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12481         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12482
12483
12484         ut_params->sess = rte_cryptodev_sym_session_create(
12485                         ts_params->session_mpool);
12486         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12487
12488         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12489                         &ut_params->auth_xform,
12490                         ts_params->session_priv_mpool);
12491
12492         return status;
12493 }
12494
12495 static int
12496 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12497 {
12498         struct crypto_testsuite_params *ts_params = &testsuite_params;
12499         struct crypto_unittest_params *ut_params = &unittest_params;
12500         struct rte_cryptodev_info dev_info;
12501
12502         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12503         uint64_t feat_flags = dev_info.feature_flags;
12504
12505         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12506                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12507                 printf("Device doesn't support RAW data-path APIs.\n");
12508                 return TEST_SKIPPED;
12509         }
12510
12511         int retval;
12512
12513         uint8_t *auth_tag, *plaintext;
12514         uint16_t plaintext_pad_len;
12515
12516         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12517                               "No GMAC length in the source data");
12518
12519         /* Verify the capabilities */
12520         struct rte_cryptodev_sym_capability_idx cap_idx;
12521         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12522         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12523         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12524                         &cap_idx) == NULL)
12525                 return TEST_SKIPPED;
12526
12527         retval = create_gmac_session(ts_params->valid_devs[0],
12528                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12529
12530         if (retval == -ENOTSUP)
12531                 return TEST_SKIPPED;
12532         if (retval < 0)
12533                 return retval;
12534
12535         if (tdata->plaintext.len > MBUF_SIZE)
12536                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12537         else
12538                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12539         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12540                         "Failed to allocate input buffer in mempool");
12541
12542         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12543                         rte_pktmbuf_tailroom(ut_params->ibuf));
12544
12545         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12546         /*
12547          * Runtime generate the large plain text instead of use hard code
12548          * plain text vector. It is done to avoid create huge source file
12549          * with the test vector.
12550          */
12551         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12552                 generate_gmac_large_plaintext(tdata->plaintext.data);
12553
12554         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12555                                 plaintext_pad_len);
12556         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12557
12558         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12559         debug_hexdump(stdout, "plaintext:", plaintext,
12560                         tdata->plaintext.len);
12561
12562         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12563                         tdata);
12564
12565         if (retval < 0)
12566                 return retval;
12567
12568         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12569
12570         ut_params->op->sym->m_src = ut_params->ibuf;
12571
12572         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12573                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12574                         ut_params->op);
12575         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12576                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12577                                 ut_params->op, 0, 1, 0, 0);
12578         else
12579                 TEST_ASSERT_NOT_NULL(
12580                         process_crypto_request(ts_params->valid_devs[0],
12581                         ut_params->op), "failed to process sym crypto op");
12582
12583         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12584                         "crypto op processing failed");
12585
12586         if (ut_params->op->sym->m_dst) {
12587                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12588                                 uint8_t *, plaintext_pad_len);
12589         } else {
12590                 auth_tag = plaintext + plaintext_pad_len;
12591         }
12592
12593         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12594
12595         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12596                         auth_tag,
12597                         tdata->gmac_tag.data,
12598                         tdata->gmac_tag.len,
12599                         "GMAC Generated auth tag not as expected");
12600
12601         return 0;
12602 }
12603
12604 static int
12605 test_AES_GMAC_authentication_test_case_1(void)
12606 {
12607         return test_AES_GMAC_authentication(&gmac_test_case_1);
12608 }
12609
12610 static int
12611 test_AES_GMAC_authentication_test_case_2(void)
12612 {
12613         return test_AES_GMAC_authentication(&gmac_test_case_2);
12614 }
12615
12616 static int
12617 test_AES_GMAC_authentication_test_case_3(void)
12618 {
12619         return test_AES_GMAC_authentication(&gmac_test_case_3);
12620 }
12621
12622 static int
12623 test_AES_GMAC_authentication_test_case_4(void)
12624 {
12625         return test_AES_GMAC_authentication(&gmac_test_case_4);
12626 }
12627
12628 static int
12629 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12630 {
12631         struct crypto_testsuite_params *ts_params = &testsuite_params;
12632         struct crypto_unittest_params *ut_params = &unittest_params;
12633         int retval;
12634         uint32_t plaintext_pad_len;
12635         uint8_t *plaintext;
12636         struct rte_cryptodev_info dev_info;
12637
12638         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12639         uint64_t feat_flags = dev_info.feature_flags;
12640
12641         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12642                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12643                 printf("Device doesn't support RAW data-path APIs.\n");
12644                 return TEST_SKIPPED;
12645         }
12646
12647         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12648                               "No GMAC length in the source data");
12649
12650         /* Verify the capabilities */
12651         struct rte_cryptodev_sym_capability_idx cap_idx;
12652         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12653         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12654         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12655                         &cap_idx) == NULL)
12656                 return TEST_SKIPPED;
12657
12658         retval = create_gmac_session(ts_params->valid_devs[0],
12659                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12660
12661         if (retval == -ENOTSUP)
12662                 return TEST_SKIPPED;
12663         if (retval < 0)
12664                 return retval;
12665
12666         if (tdata->plaintext.len > MBUF_SIZE)
12667                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12668         else
12669                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12670         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12671                         "Failed to allocate input buffer in mempool");
12672
12673         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12674                         rte_pktmbuf_tailroom(ut_params->ibuf));
12675
12676         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12677
12678         /*
12679          * Runtime generate the large plain text instead of use hard code
12680          * plain text vector. It is done to avoid create huge source file
12681          * with the test vector.
12682          */
12683         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12684                 generate_gmac_large_plaintext(tdata->plaintext.data);
12685
12686         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12687                                 plaintext_pad_len);
12688         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12689
12690         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12691         debug_hexdump(stdout, "plaintext:", plaintext,
12692                         tdata->plaintext.len);
12693
12694         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12695                         tdata);
12696
12697         if (retval < 0)
12698                 return retval;
12699
12700         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12701
12702         ut_params->op->sym->m_src = ut_params->ibuf;
12703
12704         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12705                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12706                         ut_params->op);
12707         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12708                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12709                                 ut_params->op, 0, 1, 0, 0);
12710         else
12711                 TEST_ASSERT_NOT_NULL(
12712                         process_crypto_request(ts_params->valid_devs[0],
12713                         ut_params->op), "failed to process sym crypto op");
12714
12715         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12716                         "crypto op processing failed");
12717
12718         return 0;
12719
12720 }
12721
12722 static int
12723 test_AES_GMAC_authentication_verify_test_case_1(void)
12724 {
12725         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
12726 }
12727
12728 static int
12729 test_AES_GMAC_authentication_verify_test_case_2(void)
12730 {
12731         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
12732 }
12733
12734 static int
12735 test_AES_GMAC_authentication_verify_test_case_3(void)
12736 {
12737         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
12738 }
12739
12740 static int
12741 test_AES_GMAC_authentication_verify_test_case_4(void)
12742 {
12743         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
12744 }
12745
12746 static int
12747 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
12748                                 uint32_t fragsz)
12749 {
12750         struct crypto_testsuite_params *ts_params = &testsuite_params;
12751         struct crypto_unittest_params *ut_params = &unittest_params;
12752         struct rte_cryptodev_info dev_info;
12753         uint64_t feature_flags;
12754         unsigned int trn_data = 0;
12755         void *digest_mem = NULL;
12756         uint32_t segs = 1;
12757         unsigned int to_trn = 0;
12758         struct rte_mbuf *buf = NULL;
12759         uint8_t *auth_tag, *plaintext;
12760         int retval;
12761
12762         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12763                               "No GMAC length in the source data");
12764
12765         /* Verify the capabilities */
12766         struct rte_cryptodev_sym_capability_idx cap_idx;
12767         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12768         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12769         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12770                         &cap_idx) == NULL)
12771                 return TEST_SKIPPED;
12772
12773         /* Check for any input SGL support */
12774         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12775         feature_flags = dev_info.feature_flags;
12776
12777         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
12778                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
12779                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
12780                 return TEST_SKIPPED;
12781
12782         if (fragsz > tdata->plaintext.len)
12783                 fragsz = tdata->plaintext.len;
12784
12785         uint16_t plaintext_len = fragsz;
12786
12787         retval = create_gmac_session(ts_params->valid_devs[0],
12788                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12789
12790         if (retval == -ENOTSUP)
12791                 return TEST_SKIPPED;
12792         if (retval < 0)
12793                 return retval;
12794
12795         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12796         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12797                         "Failed to allocate input buffer in mempool");
12798
12799         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12800                         rte_pktmbuf_tailroom(ut_params->ibuf));
12801
12802         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12803                                 plaintext_len);
12804         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12805
12806         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
12807
12808         trn_data += plaintext_len;
12809
12810         buf = ut_params->ibuf;
12811
12812         /*
12813          * Loop until no more fragments
12814          */
12815
12816         while (trn_data < tdata->plaintext.len) {
12817                 ++segs;
12818                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
12819                                 (tdata->plaintext.len - trn_data) : fragsz;
12820
12821                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12822                 buf = buf->next;
12823
12824                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
12825                                 rte_pktmbuf_tailroom(buf));
12826
12827                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
12828                                 to_trn);
12829
12830                 memcpy(plaintext, tdata->plaintext.data + trn_data,
12831                                 to_trn);
12832                 trn_data += to_trn;
12833                 if (trn_data  == tdata->plaintext.len)
12834                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
12835                                         tdata->gmac_tag.len);
12836         }
12837         ut_params->ibuf->nb_segs = segs;
12838
12839         /*
12840          * Place digest at the end of the last buffer
12841          */
12842         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
12843
12844         if (!digest_mem) {
12845                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12846                                 + tdata->gmac_tag.len);
12847                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
12848                                 tdata->plaintext.len);
12849         }
12850
12851         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
12852                         tdata, digest_mem, digest_phys);
12853
12854         if (retval < 0)
12855                 return retval;
12856
12857         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12858
12859         ut_params->op->sym->m_src = ut_params->ibuf;
12860
12861         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12862                 return TEST_SKIPPED;
12863
12864         TEST_ASSERT_NOT_NULL(
12865                 process_crypto_request(ts_params->valid_devs[0],
12866                 ut_params->op), "failed to process sym crypto op");
12867
12868         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12869                         "crypto op processing failed");
12870
12871         auth_tag = digest_mem;
12872         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12873         TEST_ASSERT_BUFFERS_ARE_EQUAL(
12874                         auth_tag,
12875                         tdata->gmac_tag.data,
12876                         tdata->gmac_tag.len,
12877                         "GMAC Generated auth tag not as expected");
12878
12879         return 0;
12880 }
12881
12882 /* Segment size not multiple of block size (16B) */
12883 static int
12884 test_AES_GMAC_authentication_SGL_40B(void)
12885 {
12886         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
12887 }
12888
12889 static int
12890 test_AES_GMAC_authentication_SGL_80B(void)
12891 {
12892         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
12893 }
12894
12895 static int
12896 test_AES_GMAC_authentication_SGL_2048B(void)
12897 {
12898         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
12899 }
12900
12901 /* Segment size not multiple of block size (16B) */
12902 static int
12903 test_AES_GMAC_authentication_SGL_2047B(void)
12904 {
12905         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
12906 }
12907
12908 struct test_crypto_vector {
12909         enum rte_crypto_cipher_algorithm crypto_algo;
12910         unsigned int cipher_offset;
12911         unsigned int cipher_len;
12912
12913         struct {
12914                 uint8_t data[64];
12915                 unsigned int len;
12916         } cipher_key;
12917
12918         struct {
12919                 uint8_t data[64];
12920                 unsigned int len;
12921         } iv;
12922
12923         struct {
12924                 const uint8_t *data;
12925                 unsigned int len;
12926         } plaintext;
12927
12928         struct {
12929                 const uint8_t *data;
12930                 unsigned int len;
12931         } ciphertext;
12932
12933         enum rte_crypto_auth_algorithm auth_algo;
12934         unsigned int auth_offset;
12935
12936         struct {
12937                 uint8_t data[128];
12938                 unsigned int len;
12939         } auth_key;
12940
12941         struct {
12942                 const uint8_t *data;
12943                 unsigned int len;
12944         } aad;
12945
12946         struct {
12947                 uint8_t data[128];
12948                 unsigned int len;
12949         } digest;
12950 };
12951
12952 static const struct test_crypto_vector
12953 hmac_sha1_test_crypto_vector = {
12954         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
12955         .plaintext = {
12956                 .data = plaintext_hash,
12957                 .len = 512
12958         },
12959         .auth_key = {
12960                 .data = {
12961                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
12962                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
12963                         0xDE, 0xF4, 0xDE, 0xAD
12964                 },
12965                 .len = 20
12966         },
12967         .digest = {
12968                 .data = {
12969                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
12970                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
12971                         0x3F, 0x91, 0x64, 0x59
12972                 },
12973                 .len = 20
12974         }
12975 };
12976
12977 static const struct test_crypto_vector
12978 aes128_gmac_test_vector = {
12979         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
12980         .plaintext = {
12981                 .data = plaintext_hash,
12982                 .len = 512
12983         },
12984         .iv = {
12985                 .data = {
12986                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
12987                         0x08, 0x09, 0x0A, 0x0B
12988                 },
12989                 .len = 12
12990         },
12991         .auth_key = {
12992                 .data = {
12993                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
12994                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
12995                 },
12996                 .len = 16
12997         },
12998         .digest = {
12999                 .data = {
13000                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
13001                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
13002                 },
13003                 .len = 16
13004         }
13005 };
13006
13007 static const struct test_crypto_vector
13008 aes128cbc_hmac_sha1_test_vector = {
13009         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13010         .cipher_offset = 0,
13011         .cipher_len = 512,
13012         .cipher_key = {
13013                 .data = {
13014                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13015                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13016                 },
13017                 .len = 16
13018         },
13019         .iv = {
13020                 .data = {
13021                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13022                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13023                 },
13024                 .len = 16
13025         },
13026         .plaintext = {
13027                 .data = plaintext_hash,
13028                 .len = 512
13029         },
13030         .ciphertext = {
13031                 .data = ciphertext512_aes128cbc,
13032                 .len = 512
13033         },
13034         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13035         .auth_offset = 0,
13036         .auth_key = {
13037                 .data = {
13038                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13039                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13040                         0xDE, 0xF4, 0xDE, 0xAD
13041                 },
13042                 .len = 20
13043         },
13044         .digest = {
13045                 .data = {
13046                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
13047                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13048                         0x18, 0x8C, 0x1D, 0x32
13049                 },
13050                 .len = 20
13051         }
13052 };
13053
13054 static const struct test_crypto_vector
13055 aes128cbc_hmac_sha1_aad_test_vector = {
13056         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13057         .cipher_offset = 8,
13058         .cipher_len = 496,
13059         .cipher_key = {
13060                 .data = {
13061                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13062                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13063                 },
13064                 .len = 16
13065         },
13066         .iv = {
13067                 .data = {
13068                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13069                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13070                 },
13071                 .len = 16
13072         },
13073         .plaintext = {
13074                 .data = plaintext_hash,
13075                 .len = 512
13076         },
13077         .ciphertext = {
13078                 .data = ciphertext512_aes128cbc_aad,
13079                 .len = 512
13080         },
13081         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13082         .auth_offset = 0,
13083         .auth_key = {
13084                 .data = {
13085                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13086                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13087                         0xDE, 0xF4, 0xDE, 0xAD
13088                 },
13089                 .len = 20
13090         },
13091         .digest = {
13092                 .data = {
13093                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
13094                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
13095                         0x62, 0x0F, 0xFB, 0x10
13096                 },
13097                 .len = 20
13098         }
13099 };
13100
13101 static void
13102 data_corruption(uint8_t *data)
13103 {
13104         data[0] += 1;
13105 }
13106
13107 static void
13108 tag_corruption(uint8_t *data, unsigned int tag_offset)
13109 {
13110         data[tag_offset] += 1;
13111 }
13112
13113 static int
13114 create_auth_session(struct crypto_unittest_params *ut_params,
13115                 uint8_t dev_id,
13116                 const struct test_crypto_vector *reference,
13117                 enum rte_crypto_auth_operation auth_op)
13118 {
13119         struct crypto_testsuite_params *ts_params = &testsuite_params;
13120         uint8_t auth_key[reference->auth_key.len + 1];
13121         int status;
13122
13123         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13124
13125         /* Setup Authentication Parameters */
13126         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13127         ut_params->auth_xform.auth.op = auth_op;
13128         ut_params->auth_xform.next = NULL;
13129         ut_params->auth_xform.auth.algo = reference->auth_algo;
13130         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13131         ut_params->auth_xform.auth.key.data = auth_key;
13132         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13133
13134         /* Create Crypto session*/
13135         ut_params->sess = rte_cryptodev_sym_session_create(
13136                         ts_params->session_mpool);
13137         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13138
13139         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13140                                 &ut_params->auth_xform,
13141                                 ts_params->session_priv_mpool);
13142
13143         return status;
13144 }
13145
13146 static int
13147 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
13148                 uint8_t dev_id,
13149                 const struct test_crypto_vector *reference,
13150                 enum rte_crypto_auth_operation auth_op,
13151                 enum rte_crypto_cipher_operation cipher_op)
13152 {
13153         struct crypto_testsuite_params *ts_params = &testsuite_params;
13154         uint8_t cipher_key[reference->cipher_key.len + 1];
13155         uint8_t auth_key[reference->auth_key.len + 1];
13156         int status;
13157
13158         memcpy(cipher_key, reference->cipher_key.data,
13159                         reference->cipher_key.len);
13160         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13161
13162         /* Setup Authentication Parameters */
13163         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13164         ut_params->auth_xform.auth.op = auth_op;
13165         ut_params->auth_xform.auth.algo = reference->auth_algo;
13166         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13167         ut_params->auth_xform.auth.key.data = auth_key;
13168         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13169
13170         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
13171                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
13172                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
13173         } else {
13174                 ut_params->auth_xform.next = &ut_params->cipher_xform;
13175
13176                 /* Setup Cipher Parameters */
13177                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13178                 ut_params->cipher_xform.next = NULL;
13179                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13180                 ut_params->cipher_xform.cipher.op = cipher_op;
13181                 ut_params->cipher_xform.cipher.key.data = cipher_key;
13182                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13183                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13184                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13185         }
13186
13187         /* Create Crypto session*/
13188         ut_params->sess = rte_cryptodev_sym_session_create(
13189                         ts_params->session_mpool);
13190         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13191
13192         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13193                                 &ut_params->auth_xform,
13194                                 ts_params->session_priv_mpool);
13195
13196         return status;
13197 }
13198
13199 static int
13200 create_auth_operation(struct crypto_testsuite_params *ts_params,
13201                 struct crypto_unittest_params *ut_params,
13202                 const struct test_crypto_vector *reference,
13203                 unsigned int auth_generate)
13204 {
13205         /* Generate Crypto op data structure */
13206         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13207                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13208         TEST_ASSERT_NOT_NULL(ut_params->op,
13209                         "Failed to allocate pktmbuf offload");
13210
13211         /* Set crypto operation data parameters */
13212         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13213
13214         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13215
13216         /* set crypto operation source mbuf */
13217         sym_op->m_src = ut_params->ibuf;
13218
13219         /* digest */
13220         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13221                         ut_params->ibuf, reference->digest.len);
13222
13223         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13224                         "no room to append auth tag");
13225
13226         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13227                         ut_params->ibuf, reference->plaintext.len);
13228
13229         if (auth_generate)
13230                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13231         else
13232                 memcpy(sym_op->auth.digest.data,
13233                                 reference->digest.data,
13234                                 reference->digest.len);
13235
13236         debug_hexdump(stdout, "digest:",
13237                         sym_op->auth.digest.data,
13238                         reference->digest.len);
13239
13240         sym_op->auth.data.length = reference->plaintext.len;
13241         sym_op->auth.data.offset = 0;
13242
13243         return 0;
13244 }
13245
13246 static int
13247 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13248                 struct crypto_unittest_params *ut_params,
13249                 const struct test_crypto_vector *reference,
13250                 unsigned int auth_generate)
13251 {
13252         /* Generate Crypto op data structure */
13253         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13254                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13255         TEST_ASSERT_NOT_NULL(ut_params->op,
13256                         "Failed to allocate pktmbuf offload");
13257
13258         /* Set crypto operation data parameters */
13259         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13260
13261         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13262
13263         /* set crypto operation source mbuf */
13264         sym_op->m_src = ut_params->ibuf;
13265
13266         /* digest */
13267         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13268                         ut_params->ibuf, reference->digest.len);
13269
13270         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13271                         "no room to append auth tag");
13272
13273         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13274                         ut_params->ibuf, reference->ciphertext.len);
13275
13276         if (auth_generate)
13277                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13278         else
13279                 memcpy(sym_op->auth.digest.data,
13280                                 reference->digest.data,
13281                                 reference->digest.len);
13282
13283         debug_hexdump(stdout, "digest:",
13284                         sym_op->auth.digest.data,
13285                         reference->digest.len);
13286
13287         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13288                         reference->iv.data, reference->iv.len);
13289
13290         sym_op->cipher.data.length = 0;
13291         sym_op->cipher.data.offset = 0;
13292
13293         sym_op->auth.data.length = reference->plaintext.len;
13294         sym_op->auth.data.offset = 0;
13295
13296         return 0;
13297 }
13298
13299 static int
13300 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13301                 struct crypto_unittest_params *ut_params,
13302                 const struct test_crypto_vector *reference,
13303                 unsigned int auth_generate)
13304 {
13305         /* Generate Crypto op data structure */
13306         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13307                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13308         TEST_ASSERT_NOT_NULL(ut_params->op,
13309                         "Failed to allocate pktmbuf offload");
13310
13311         /* Set crypto operation data parameters */
13312         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13313
13314         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13315
13316         /* set crypto operation source mbuf */
13317         sym_op->m_src = ut_params->ibuf;
13318
13319         /* digest */
13320         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13321                         ut_params->ibuf, reference->digest.len);
13322
13323         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13324                         "no room to append auth tag");
13325
13326         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13327                         ut_params->ibuf, reference->ciphertext.len);
13328
13329         if (auth_generate)
13330                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13331         else
13332                 memcpy(sym_op->auth.digest.data,
13333                                 reference->digest.data,
13334                                 reference->digest.len);
13335
13336         debug_hexdump(stdout, "digest:",
13337                         sym_op->auth.digest.data,
13338                         reference->digest.len);
13339
13340         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13341                         reference->iv.data, reference->iv.len);
13342
13343         sym_op->cipher.data.length = reference->cipher_len;
13344         sym_op->cipher.data.offset = reference->cipher_offset;
13345
13346         sym_op->auth.data.length = reference->plaintext.len;
13347         sym_op->auth.data.offset = reference->auth_offset;
13348
13349         return 0;
13350 }
13351
13352 static int
13353 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13354                 struct crypto_unittest_params *ut_params,
13355                 const struct test_crypto_vector *reference)
13356 {
13357         return create_auth_operation(ts_params, ut_params, reference, 0);
13358 }
13359
13360 static int
13361 create_auth_verify_GMAC_operation(
13362                 struct crypto_testsuite_params *ts_params,
13363                 struct crypto_unittest_params *ut_params,
13364                 const struct test_crypto_vector *reference)
13365 {
13366         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13367 }
13368
13369 static int
13370 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13371                 struct crypto_unittest_params *ut_params,
13372                 const struct test_crypto_vector *reference)
13373 {
13374         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13375 }
13376
13377 static int
13378 test_authentication_verify_fail_when_data_corruption(
13379                 struct crypto_testsuite_params *ts_params,
13380                 struct crypto_unittest_params *ut_params,
13381                 const struct test_crypto_vector *reference,
13382                 unsigned int data_corrupted)
13383 {
13384         int retval;
13385
13386         uint8_t *plaintext;
13387         struct rte_cryptodev_info dev_info;
13388
13389         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13390         uint64_t feat_flags = dev_info.feature_flags;
13391
13392         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13393                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13394                 printf("Device doesn't support RAW data-path APIs.\n");
13395                 return TEST_SKIPPED;
13396         }
13397
13398         /* Verify the capabilities */
13399         struct rte_cryptodev_sym_capability_idx cap_idx;
13400         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13401         cap_idx.algo.auth = reference->auth_algo;
13402         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13403                         &cap_idx) == NULL)
13404                 return TEST_SKIPPED;
13405
13406
13407         /* Create session */
13408         retval = create_auth_session(ut_params,
13409                         ts_params->valid_devs[0],
13410                         reference,
13411                         RTE_CRYPTO_AUTH_OP_VERIFY);
13412
13413         if (retval == -ENOTSUP)
13414                 return TEST_SKIPPED;
13415         if (retval < 0)
13416                 return retval;
13417
13418         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13419         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13420                         "Failed to allocate input buffer in mempool");
13421
13422         /* clear mbuf payload */
13423         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13424                         rte_pktmbuf_tailroom(ut_params->ibuf));
13425
13426         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13427                         reference->plaintext.len);
13428         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13429         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13430
13431         debug_hexdump(stdout, "plaintext:", plaintext,
13432                 reference->plaintext.len);
13433
13434         /* Create operation */
13435         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13436
13437         if (retval < 0)
13438                 return retval;
13439
13440         if (data_corrupted)
13441                 data_corruption(plaintext);
13442         else
13443                 tag_corruption(plaintext, reference->plaintext.len);
13444
13445         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13446                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13447                         ut_params->op);
13448                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13449                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13450                         "authentication not failed");
13451         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13452                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13453                                 ut_params->op, 0, 1, 0, 0);
13454         else {
13455                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13456                         ut_params->op);
13457         }
13458         if (ut_params->op == NULL)
13459                 return 0;
13460         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13461                 return 0;
13462
13463         return -1;
13464 }
13465
13466 static int
13467 test_authentication_verify_GMAC_fail_when_corruption(
13468                 struct crypto_testsuite_params *ts_params,
13469                 struct crypto_unittest_params *ut_params,
13470                 const struct test_crypto_vector *reference,
13471                 unsigned int data_corrupted)
13472 {
13473         int retval;
13474         uint8_t *plaintext;
13475         struct rte_cryptodev_info dev_info;
13476
13477         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13478         uint64_t feat_flags = dev_info.feature_flags;
13479
13480         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13481                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13482                 printf("Device doesn't support RAW data-path APIs.\n");
13483                 return TEST_SKIPPED;
13484         }
13485
13486         /* Verify the capabilities */
13487         struct rte_cryptodev_sym_capability_idx cap_idx;
13488         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13489         cap_idx.algo.auth = reference->auth_algo;
13490         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13491                         &cap_idx) == NULL)
13492                 return TEST_SKIPPED;
13493
13494         /* Create session */
13495         retval = create_auth_cipher_session(ut_params,
13496                         ts_params->valid_devs[0],
13497                         reference,
13498                         RTE_CRYPTO_AUTH_OP_VERIFY,
13499                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13500         if (retval < 0)
13501                 return retval;
13502
13503         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13504         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13505                         "Failed to allocate input buffer in mempool");
13506
13507         /* clear mbuf payload */
13508         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13509                         rte_pktmbuf_tailroom(ut_params->ibuf));
13510
13511         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13512                         reference->plaintext.len);
13513         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13514         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13515
13516         debug_hexdump(stdout, "plaintext:", plaintext,
13517                 reference->plaintext.len);
13518
13519         /* Create operation */
13520         retval = create_auth_verify_GMAC_operation(ts_params,
13521                         ut_params,
13522                         reference);
13523
13524         if (retval < 0)
13525                 return retval;
13526
13527         if (data_corrupted)
13528                 data_corruption(plaintext);
13529         else
13530                 tag_corruption(plaintext, reference->aad.len);
13531
13532         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13533                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13534                         ut_params->op);
13535                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13536                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13537                         "authentication not failed");
13538         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13539                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13540                                 ut_params->op, 0, 1, 0, 0);
13541         else {
13542                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13543                         ut_params->op);
13544                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13545         }
13546
13547         return 0;
13548 }
13549
13550 static int
13551 test_authenticated_decryption_fail_when_corruption(
13552                 struct crypto_testsuite_params *ts_params,
13553                 struct crypto_unittest_params *ut_params,
13554                 const struct test_crypto_vector *reference,
13555                 unsigned int data_corrupted)
13556 {
13557         int retval;
13558
13559         uint8_t *ciphertext;
13560         struct rte_cryptodev_info dev_info;
13561
13562         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13563         uint64_t feat_flags = dev_info.feature_flags;
13564
13565         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13566                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13567                 printf("Device doesn't support RAW data-path APIs.\n");
13568                 return TEST_SKIPPED;
13569         }
13570
13571         /* Verify the capabilities */
13572         struct rte_cryptodev_sym_capability_idx cap_idx;
13573         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13574         cap_idx.algo.auth = reference->auth_algo;
13575         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13576                         &cap_idx) == NULL)
13577                 return TEST_SKIPPED;
13578         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13579         cap_idx.algo.cipher = reference->crypto_algo;
13580         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13581                         &cap_idx) == NULL)
13582                 return TEST_SKIPPED;
13583
13584         /* Create session */
13585         retval = create_auth_cipher_session(ut_params,
13586                         ts_params->valid_devs[0],
13587                         reference,
13588                         RTE_CRYPTO_AUTH_OP_VERIFY,
13589                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13590
13591         if (retval == -ENOTSUP)
13592                 return TEST_SKIPPED;
13593         if (retval < 0)
13594                 return retval;
13595
13596         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13597         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13598                         "Failed to allocate input buffer in mempool");
13599
13600         /* clear mbuf payload */
13601         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13602                         rte_pktmbuf_tailroom(ut_params->ibuf));
13603
13604         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13605                         reference->ciphertext.len);
13606         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13607         memcpy(ciphertext, reference->ciphertext.data,
13608                         reference->ciphertext.len);
13609
13610         /* Create operation */
13611         retval = create_cipher_auth_verify_operation(ts_params,
13612                         ut_params,
13613                         reference);
13614
13615         if (retval < 0)
13616                 return retval;
13617
13618         if (data_corrupted)
13619                 data_corruption(ciphertext);
13620         else
13621                 tag_corruption(ciphertext, reference->ciphertext.len);
13622
13623         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13624                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13625                         ut_params->op);
13626                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13627                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13628                         "authentication not failed");
13629         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13630                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13631                                 ut_params->op, 1, 1, 0, 0);
13632         else {
13633                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13634                         ut_params->op);
13635                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13636         }
13637
13638         return 0;
13639 }
13640
13641 static int
13642 test_authenticated_encrypt_with_esn(
13643                 struct crypto_testsuite_params *ts_params,
13644                 struct crypto_unittest_params *ut_params,
13645                 const struct test_crypto_vector *reference)
13646 {
13647         int retval;
13648
13649         uint8_t *authciphertext, *plaintext, *auth_tag;
13650         uint16_t plaintext_pad_len;
13651         uint8_t cipher_key[reference->cipher_key.len + 1];
13652         uint8_t auth_key[reference->auth_key.len + 1];
13653         struct rte_cryptodev_info dev_info;
13654         int status;
13655
13656         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13657         uint64_t feat_flags = dev_info.feature_flags;
13658
13659         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13660                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13661                 printf("Device doesn't support RAW data-path APIs.\n");
13662                 return TEST_SKIPPED;
13663         }
13664
13665         /* Verify the capabilities */
13666         struct rte_cryptodev_sym_capability_idx cap_idx;
13667         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13668         cap_idx.algo.auth = reference->auth_algo;
13669         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13670                         &cap_idx) == NULL)
13671                 return TEST_SKIPPED;
13672         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13673         cap_idx.algo.cipher = reference->crypto_algo;
13674         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13675                         &cap_idx) == NULL)
13676                 return TEST_SKIPPED;
13677
13678         /* Create session */
13679         memcpy(cipher_key, reference->cipher_key.data,
13680                         reference->cipher_key.len);
13681         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13682
13683         /* Setup Cipher Parameters */
13684         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13685         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13686         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13687         ut_params->cipher_xform.cipher.key.data = cipher_key;
13688         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13689         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13690         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13691
13692         ut_params->cipher_xform.next = &ut_params->auth_xform;
13693
13694         /* Setup Authentication Parameters */
13695         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13696         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13697         ut_params->auth_xform.auth.algo = reference->auth_algo;
13698         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13699         ut_params->auth_xform.auth.key.data = auth_key;
13700         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13701         ut_params->auth_xform.next = NULL;
13702
13703         /* Create Crypto session*/
13704         ut_params->sess = rte_cryptodev_sym_session_create(
13705                         ts_params->session_mpool);
13706         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13707
13708         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13709                                 ut_params->sess,
13710                                 &ut_params->cipher_xform,
13711                                 ts_params->session_priv_mpool);
13712
13713         if (status == -ENOTSUP)
13714                 return TEST_SKIPPED;
13715
13716         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13717
13718         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13719         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13720                         "Failed to allocate input buffer in mempool");
13721
13722         /* clear mbuf payload */
13723         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13724                         rte_pktmbuf_tailroom(ut_params->ibuf));
13725
13726         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13727                         reference->plaintext.len);
13728         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13729         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13730
13731         /* Create operation */
13732         retval = create_cipher_auth_operation(ts_params,
13733                         ut_params,
13734                         reference, 0);
13735
13736         if (retval < 0)
13737                 return retval;
13738
13739         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13740                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13741                         ut_params->op);
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, 1, 1, 0, 0);
13745         else
13746                 ut_params->op = process_crypto_request(
13747                         ts_params->valid_devs[0], ut_params->op);
13748
13749         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
13750
13751         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13752                         "crypto op processing failed");
13753
13754         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
13755
13756         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
13757                         ut_params->op->sym->auth.data.offset);
13758         auth_tag = authciphertext + plaintext_pad_len;
13759         debug_hexdump(stdout, "ciphertext:", authciphertext,
13760                         reference->ciphertext.len);
13761         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
13762
13763         /* Validate obuf */
13764         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13765                         authciphertext,
13766                         reference->ciphertext.data,
13767                         reference->ciphertext.len,
13768                         "Ciphertext data not as expected");
13769
13770         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13771                         auth_tag,
13772                         reference->digest.data,
13773                         reference->digest.len,
13774                         "Generated digest not as expected");
13775
13776         return TEST_SUCCESS;
13777
13778 }
13779
13780 static int
13781 test_authenticated_decrypt_with_esn(
13782                 struct crypto_testsuite_params *ts_params,
13783                 struct crypto_unittest_params *ut_params,
13784                 const struct test_crypto_vector *reference)
13785 {
13786         int retval;
13787
13788         uint8_t *ciphertext;
13789         uint8_t cipher_key[reference->cipher_key.len + 1];
13790         uint8_t auth_key[reference->auth_key.len + 1];
13791         struct rte_cryptodev_info dev_info;
13792
13793         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13794         uint64_t feat_flags = dev_info.feature_flags;
13795
13796         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13797                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13798                 printf("Device doesn't support RAW data-path APIs.\n");
13799                 return TEST_SKIPPED;
13800         }
13801
13802         /* Verify the capabilities */
13803         struct rte_cryptodev_sym_capability_idx cap_idx;
13804         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13805         cap_idx.algo.auth = reference->auth_algo;
13806         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13807                         &cap_idx) == NULL)
13808                 return TEST_SKIPPED;
13809         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13810         cap_idx.algo.cipher = reference->crypto_algo;
13811         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13812                         &cap_idx) == NULL)
13813                 return TEST_SKIPPED;
13814
13815         /* Create session */
13816         memcpy(cipher_key, reference->cipher_key.data,
13817                         reference->cipher_key.len);
13818         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13819
13820         /* Setup Authentication Parameters */
13821         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13822         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
13823         ut_params->auth_xform.auth.algo = reference->auth_algo;
13824         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13825         ut_params->auth_xform.auth.key.data = auth_key;
13826         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13827         ut_params->auth_xform.next = &ut_params->cipher_xform;
13828
13829         /* Setup Cipher Parameters */
13830         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13831         ut_params->cipher_xform.next = NULL;
13832         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13833         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
13834         ut_params->cipher_xform.cipher.key.data = cipher_key;
13835         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13836         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13837         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13838
13839         /* Create Crypto session*/
13840         ut_params->sess = rte_cryptodev_sym_session_create(
13841                         ts_params->session_mpool);
13842         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13843
13844         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13845                                 ut_params->sess,
13846                                 &ut_params->auth_xform,
13847                                 ts_params->session_priv_mpool);
13848
13849         if (retval == -ENOTSUP)
13850                 return TEST_SKIPPED;
13851
13852         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
13853
13854         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13855         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13856                         "Failed to allocate input buffer in mempool");
13857
13858         /* clear mbuf payload */
13859         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13860                         rte_pktmbuf_tailroom(ut_params->ibuf));
13861
13862         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13863                         reference->ciphertext.len);
13864         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13865         memcpy(ciphertext, reference->ciphertext.data,
13866                         reference->ciphertext.len);
13867
13868         /* Create operation */
13869         retval = create_cipher_auth_verify_operation(ts_params,
13870                         ut_params,
13871                         reference);
13872
13873         if (retval < 0)
13874                 return retval;
13875
13876         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13877                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13878                         ut_params->op);
13879         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13880                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13881                                 ut_params->op, 1, 1, 0, 0);
13882         else
13883                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13884                         ut_params->op);
13885
13886         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
13887         TEST_ASSERT_EQUAL(ut_params->op->status,
13888                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13889                         "crypto op processing passed");
13890
13891         ut_params->obuf = ut_params->op->sym->m_src;
13892         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
13893
13894         return 0;
13895 }
13896
13897 static int
13898 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
13899                 const struct aead_test_data *tdata,
13900                 void *digest_mem, uint64_t digest_phys)
13901 {
13902         struct crypto_testsuite_params *ts_params = &testsuite_params;
13903         struct crypto_unittest_params *ut_params = &unittest_params;
13904
13905         const unsigned int auth_tag_len = tdata->auth_tag.len;
13906         const unsigned int iv_len = tdata->iv.len;
13907         unsigned int aad_len = tdata->aad.len;
13908         unsigned int aad_len_pad = 0;
13909
13910         /* Generate Crypto op data structure */
13911         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13912                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13913         TEST_ASSERT_NOT_NULL(ut_params->op,
13914                 "Failed to allocate symmetric crypto operation struct");
13915
13916         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13917
13918         sym_op->aead.digest.data = digest_mem;
13919
13920         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
13921                         "no room to append digest");
13922
13923         sym_op->aead.digest.phys_addr = digest_phys;
13924
13925         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
13926                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
13927                                 auth_tag_len);
13928                 debug_hexdump(stdout, "digest:",
13929                                 sym_op->aead.digest.data,
13930                                 auth_tag_len);
13931         }
13932
13933         /* Append aad data */
13934         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
13935                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13936                                 uint8_t *, IV_OFFSET);
13937
13938                 /* Copy IV 1 byte after the IV pointer, according to the API */
13939                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
13940
13941                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
13942
13943                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13944                                 ut_params->ibuf, aad_len);
13945                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13946                                 "no room to prepend aad");
13947                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13948                                 ut_params->ibuf);
13949
13950                 memset(sym_op->aead.aad.data, 0, aad_len);
13951                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
13952                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13953
13954                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13955                 debug_hexdump(stdout, "aad:",
13956                                 sym_op->aead.aad.data, aad_len);
13957         } else {
13958                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
13959                                 uint8_t *, IV_OFFSET);
13960
13961                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
13962
13963                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
13964
13965                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
13966                                 ut_params->ibuf, aad_len_pad);
13967                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
13968                                 "no room to prepend aad");
13969                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
13970                                 ut_params->ibuf);
13971
13972                 memset(sym_op->aead.aad.data, 0, aad_len);
13973                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
13974
13975                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
13976                 debug_hexdump(stdout, "aad:",
13977                                 sym_op->aead.aad.data, aad_len);
13978         }
13979
13980         sym_op->aead.data.length = tdata->plaintext.len;
13981         sym_op->aead.data.offset = aad_len_pad;
13982
13983         return 0;
13984 }
13985
13986 #define SGL_MAX_NO      16
13987
13988 static int
13989 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
13990                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
13991 {
13992         struct crypto_testsuite_params *ts_params = &testsuite_params;
13993         struct crypto_unittest_params *ut_params = &unittest_params;
13994         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
13995         int retval;
13996         int to_trn = 0;
13997         int to_trn_tbl[SGL_MAX_NO];
13998         int segs = 1;
13999         unsigned int trn_data = 0;
14000         uint8_t *plaintext, *ciphertext, *auth_tag;
14001         struct rte_cryptodev_info dev_info;
14002
14003         /* Verify the capabilities */
14004         struct rte_cryptodev_sym_capability_idx cap_idx;
14005         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
14006         cap_idx.algo.aead = tdata->algo;
14007         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14008                         &cap_idx) == NULL)
14009                 return TEST_SKIPPED;
14010
14011         /* OOP not supported with CPU crypto */
14012         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14013                 return TEST_SKIPPED;
14014
14015         /* Detailed check for the particular SGL support flag */
14016         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14017         if (!oop) {
14018                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14019                 if (sgl_in && (!(dev_info.feature_flags &
14020                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
14021                         return TEST_SKIPPED;
14022
14023                 uint64_t feat_flags = dev_info.feature_flags;
14024
14025                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14026                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14027                         printf("Device doesn't support RAW data-path APIs.\n");
14028                         return TEST_SKIPPED;
14029                 }
14030         } else {
14031                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14032                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
14033                                 tdata->plaintext.len;
14034                 /* Raw data path API does not support OOP */
14035                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14036                         return TEST_SKIPPED;
14037                 if (sgl_in && !sgl_out) {
14038                         if (!(dev_info.feature_flags &
14039                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
14040                                 return TEST_SKIPPED;
14041                 } else if (!sgl_in && sgl_out) {
14042                         if (!(dev_info.feature_flags &
14043                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
14044                                 return TEST_SKIPPED;
14045                 } else if (sgl_in && sgl_out) {
14046                         if (!(dev_info.feature_flags &
14047                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
14048                                 return TEST_SKIPPED;
14049                 }
14050         }
14051
14052         if (fragsz > tdata->plaintext.len)
14053                 fragsz = tdata->plaintext.len;
14054
14055         uint16_t plaintext_len = fragsz;
14056         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
14057
14058         if (fragsz_oop > tdata->plaintext.len)
14059                 frag_size_oop = tdata->plaintext.len;
14060
14061         int ecx = 0;
14062         void *digest_mem = NULL;
14063
14064         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
14065
14066         if (tdata->plaintext.len % fragsz != 0) {
14067                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
14068                         return 1;
14069         }       else {
14070                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
14071                         return 1;
14072         }
14073
14074         /*
14075          * For out-op-place we need to alloc another mbuf
14076          */
14077         if (oop) {
14078                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14079                 rte_pktmbuf_append(ut_params->obuf,
14080                                 frag_size_oop + prepend_len);
14081                 buf_oop = ut_params->obuf;
14082         }
14083
14084         /* Create AEAD session */
14085         retval = create_aead_session(ts_params->valid_devs[0],
14086                         tdata->algo,
14087                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
14088                         tdata->key.data, tdata->key.len,
14089                         tdata->aad.len, tdata->auth_tag.len,
14090                         tdata->iv.len);
14091         if (retval < 0)
14092                 return retval;
14093
14094         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14095
14096         /* clear mbuf payload */
14097         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14098                         rte_pktmbuf_tailroom(ut_params->ibuf));
14099
14100         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14101                         plaintext_len);
14102
14103         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
14104
14105         trn_data += plaintext_len;
14106
14107         buf = ut_params->ibuf;
14108
14109         /*
14110          * Loop until no more fragments
14111          */
14112
14113         while (trn_data < tdata->plaintext.len) {
14114                 ++segs;
14115                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
14116                                 (tdata->plaintext.len - trn_data) : fragsz;
14117
14118                 to_trn_tbl[ecx++] = to_trn;
14119
14120                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14121                 buf = buf->next;
14122
14123                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
14124                                 rte_pktmbuf_tailroom(buf));
14125
14126                 /* OOP */
14127                 if (oop && !fragsz_oop) {
14128                         buf_last_oop = buf_oop->next =
14129                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14130                         buf_oop = buf_oop->next;
14131                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14132                                         0, rte_pktmbuf_tailroom(buf_oop));
14133                         rte_pktmbuf_append(buf_oop, to_trn);
14134                 }
14135
14136                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
14137                                 to_trn);
14138
14139                 memcpy(plaintext, tdata->plaintext.data + trn_data,
14140                                 to_trn);
14141                 trn_data += to_trn;
14142                 if (trn_data  == tdata->plaintext.len) {
14143                         if (oop) {
14144                                 if (!fragsz_oop)
14145                                         digest_mem = rte_pktmbuf_append(buf_oop,
14146                                                 tdata->auth_tag.len);
14147                         } else
14148                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
14149                                         tdata->auth_tag.len);
14150                 }
14151         }
14152
14153         uint64_t digest_phys = 0;
14154
14155         ut_params->ibuf->nb_segs = segs;
14156
14157         segs = 1;
14158         if (fragsz_oop && oop) {
14159                 to_trn = 0;
14160                 ecx = 0;
14161
14162                 if (frag_size_oop == tdata->plaintext.len) {
14163                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
14164                                 tdata->auth_tag.len);
14165
14166                         digest_phys = rte_pktmbuf_iova_offset(
14167                                         ut_params->obuf,
14168                                         tdata->plaintext.len + prepend_len);
14169                 }
14170
14171                 trn_data = frag_size_oop;
14172                 while (trn_data < tdata->plaintext.len) {
14173                         ++segs;
14174                         to_trn =
14175                                 (tdata->plaintext.len - trn_data <
14176                                                 frag_size_oop) ?
14177                                 (tdata->plaintext.len - trn_data) :
14178                                                 frag_size_oop;
14179
14180                         to_trn_tbl[ecx++] = to_trn;
14181
14182                         buf_last_oop = buf_oop->next =
14183                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14184                         buf_oop = buf_oop->next;
14185                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14186                                         0, rte_pktmbuf_tailroom(buf_oop));
14187                         rte_pktmbuf_append(buf_oop, to_trn);
14188
14189                         trn_data += to_trn;
14190
14191                         if (trn_data  == tdata->plaintext.len) {
14192                                 digest_mem = rte_pktmbuf_append(buf_oop,
14193                                         tdata->auth_tag.len);
14194                         }
14195                 }
14196
14197                 ut_params->obuf->nb_segs = segs;
14198         }
14199
14200         /*
14201          * Place digest at the end of the last buffer
14202          */
14203         if (!digest_phys)
14204                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14205         if (oop && buf_last_oop)
14206                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14207
14208         if (!digest_mem && !oop) {
14209                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14210                                 + tdata->auth_tag.len);
14211                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14212                                 tdata->plaintext.len);
14213         }
14214
14215         /* Create AEAD operation */
14216         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14217                         tdata, digest_mem, digest_phys);
14218
14219         if (retval < 0)
14220                 return retval;
14221
14222         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14223
14224         ut_params->op->sym->m_src = ut_params->ibuf;
14225         if (oop)
14226                 ut_params->op->sym->m_dst = ut_params->obuf;
14227
14228         /* Process crypto operation */
14229         if (oop == IN_PLACE &&
14230                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14231                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14232         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14233                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14234                                 ut_params->op, 0, 0, 0, 0);
14235         else
14236                 TEST_ASSERT_NOT_NULL(
14237                         process_crypto_request(ts_params->valid_devs[0],
14238                         ut_params->op), "failed to process sym crypto op");
14239
14240         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14241                         "crypto op processing failed");
14242
14243
14244         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14245                         uint8_t *, prepend_len);
14246         if (oop) {
14247                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14248                                 uint8_t *, prepend_len);
14249         }
14250
14251         if (fragsz_oop)
14252                 fragsz = fragsz_oop;
14253
14254         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14255                         ciphertext,
14256                         tdata->ciphertext.data,
14257                         fragsz,
14258                         "Ciphertext data not as expected");
14259
14260         buf = ut_params->op->sym->m_src->next;
14261         if (oop)
14262                 buf = ut_params->op->sym->m_dst->next;
14263
14264         unsigned int off = fragsz;
14265
14266         ecx = 0;
14267         while (buf) {
14268                 ciphertext = rte_pktmbuf_mtod(buf,
14269                                 uint8_t *);
14270
14271                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14272                                 ciphertext,
14273                                 tdata->ciphertext.data + off,
14274                                 to_trn_tbl[ecx],
14275                                 "Ciphertext data not as expected");
14276
14277                 off += to_trn_tbl[ecx++];
14278                 buf = buf->next;
14279         }
14280
14281         auth_tag = digest_mem;
14282         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14283                         auth_tag,
14284                         tdata->auth_tag.data,
14285                         tdata->auth_tag.len,
14286                         "Generated auth tag not as expected");
14287
14288         return 0;
14289 }
14290
14291 static int
14292 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14293 {
14294         return test_authenticated_encryption_SGL(
14295                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14296 }
14297
14298 static int
14299 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14300 {
14301         return test_authenticated_encryption_SGL(
14302                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14303 }
14304
14305 static int
14306 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14307 {
14308         return test_authenticated_encryption_SGL(
14309                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14310                         gcm_test_case_8.plaintext.len);
14311 }
14312
14313 static int
14314 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14315 {
14316         /* This test is not for OPENSSL PMD */
14317         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14318                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14319                 return TEST_SKIPPED;
14320
14321         return test_authenticated_encryption_SGL(
14322                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14323 }
14324
14325 static int
14326 test_authentication_verify_fail_when_data_corrupted(
14327                 struct crypto_testsuite_params *ts_params,
14328                 struct crypto_unittest_params *ut_params,
14329                 const struct test_crypto_vector *reference)
14330 {
14331         return test_authentication_verify_fail_when_data_corruption(
14332                         ts_params, ut_params, reference, 1);
14333 }
14334
14335 static int
14336 test_authentication_verify_fail_when_tag_corrupted(
14337                 struct crypto_testsuite_params *ts_params,
14338                 struct crypto_unittest_params *ut_params,
14339                 const struct test_crypto_vector *reference)
14340 {
14341         return test_authentication_verify_fail_when_data_corruption(
14342                         ts_params, ut_params, reference, 0);
14343 }
14344
14345 static int
14346 test_authentication_verify_GMAC_fail_when_data_corrupted(
14347                 struct crypto_testsuite_params *ts_params,
14348                 struct crypto_unittest_params *ut_params,
14349                 const struct test_crypto_vector *reference)
14350 {
14351         return test_authentication_verify_GMAC_fail_when_corruption(
14352                         ts_params, ut_params, reference, 1);
14353 }
14354
14355 static int
14356 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14357                 struct crypto_testsuite_params *ts_params,
14358                 struct crypto_unittest_params *ut_params,
14359                 const struct test_crypto_vector *reference)
14360 {
14361         return test_authentication_verify_GMAC_fail_when_corruption(
14362                         ts_params, ut_params, reference, 0);
14363 }
14364
14365 static int
14366 test_authenticated_decryption_fail_when_data_corrupted(
14367                 struct crypto_testsuite_params *ts_params,
14368                 struct crypto_unittest_params *ut_params,
14369                 const struct test_crypto_vector *reference)
14370 {
14371         return test_authenticated_decryption_fail_when_corruption(
14372                         ts_params, ut_params, reference, 1);
14373 }
14374
14375 static int
14376 test_authenticated_decryption_fail_when_tag_corrupted(
14377                 struct crypto_testsuite_params *ts_params,
14378                 struct crypto_unittest_params *ut_params,
14379                 const struct test_crypto_vector *reference)
14380 {
14381         return test_authenticated_decryption_fail_when_corruption(
14382                         ts_params, ut_params, reference, 0);
14383 }
14384
14385 static int
14386 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14387 {
14388         return test_authentication_verify_fail_when_data_corrupted(
14389                         &testsuite_params, &unittest_params,
14390                         &hmac_sha1_test_crypto_vector);
14391 }
14392
14393 static int
14394 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14395 {
14396         return test_authentication_verify_fail_when_tag_corrupted(
14397                         &testsuite_params, &unittest_params,
14398                         &hmac_sha1_test_crypto_vector);
14399 }
14400
14401 static int
14402 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14403 {
14404         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14405                         &testsuite_params, &unittest_params,
14406                         &aes128_gmac_test_vector);
14407 }
14408
14409 static int
14410 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14411 {
14412         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14413                         &testsuite_params, &unittest_params,
14414                         &aes128_gmac_test_vector);
14415 }
14416
14417 static int
14418 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14419 {
14420         return test_authenticated_decryption_fail_when_data_corrupted(
14421                         &testsuite_params,
14422                         &unittest_params,
14423                         &aes128cbc_hmac_sha1_test_vector);
14424 }
14425
14426 static int
14427 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14428 {
14429         return test_authenticated_decryption_fail_when_tag_corrupted(
14430                         &testsuite_params,
14431                         &unittest_params,
14432                         &aes128cbc_hmac_sha1_test_vector);
14433 }
14434
14435 static int
14436 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14437 {
14438         return test_authenticated_encrypt_with_esn(
14439                         &testsuite_params,
14440                         &unittest_params,
14441                         &aes128cbc_hmac_sha1_aad_test_vector);
14442 }
14443
14444 static int
14445 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14446 {
14447         return test_authenticated_decrypt_with_esn(
14448                         &testsuite_params,
14449                         &unittest_params,
14450                         &aes128cbc_hmac_sha1_aad_test_vector);
14451 }
14452
14453 static int
14454 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14455 {
14456         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14457 }
14458
14459 static int
14460 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14461 {
14462         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14463 }
14464
14465 static int
14466 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14467 {
14468         return test_authenticated_encryption_SGL(
14469                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14470                 chacha20_poly1305_case_2.plaintext.len);
14471 }
14472
14473 #ifdef RTE_CRYPTO_SCHEDULER
14474
14475 /* global AESNI worker IDs for the scheduler test */
14476 uint8_t aesni_ids[2];
14477
14478 static int
14479 scheduler_testsuite_setup(void)
14480 {
14481         uint32_t i = 0;
14482         int32_t nb_devs, ret;
14483         char vdev_args[VDEV_ARGS_SIZE] = {""};
14484         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14485                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14486         uint16_t worker_core_count = 0;
14487         uint16_t socket_id = 0;
14488
14489         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14490                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14491
14492                 /* Identify the Worker Cores
14493                  * Use 2 worker cores for the device args
14494                  */
14495                 RTE_LCORE_FOREACH_WORKER(i) {
14496                         if (worker_core_count > 1)
14497                                 break;
14498                         snprintf(vdev_args, sizeof(vdev_args),
14499                                         "%s%d", temp_str, i);
14500                         strcpy(temp_str, vdev_args);
14501                         strlcat(temp_str, ";", sizeof(temp_str));
14502                         worker_core_count++;
14503                         socket_id = rte_lcore_to_socket_id(i);
14504                 }
14505                 if (worker_core_count != 2) {
14506                         RTE_LOG(ERR, USER1,
14507                                 "Cryptodev scheduler test require at least "
14508                                 "two worker cores to run. "
14509                                 "Please use the correct coremask.\n");
14510                         return TEST_FAILED;
14511                 }
14512                 strcpy(temp_str, vdev_args);
14513                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14514                                 temp_str, socket_id);
14515                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14516                 nb_devs = rte_cryptodev_device_count_by_driver(
14517                                 rte_cryptodev_driver_id_get(
14518                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14519                 if (nb_devs < 1) {
14520                         ret = rte_vdev_init(
14521                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14522                                         vdev_args);
14523                         TEST_ASSERT(ret == 0,
14524                                 "Failed to create instance %u of pmd : %s",
14525                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14526                 }
14527         }
14528         return testsuite_setup();
14529 }
14530
14531 static int
14532 test_scheduler_attach_worker_op(void)
14533 {
14534         struct crypto_testsuite_params *ts_params = &testsuite_params;
14535         uint8_t sched_id = ts_params->valid_devs[0];
14536         uint32_t i, nb_devs_attached = 0;
14537         int ret;
14538         char vdev_name[32];
14539         unsigned int count = rte_cryptodev_count();
14540
14541         /* create 2 AESNI_MB vdevs on top of existing devices */
14542         for (i = count; i < count + 2; i++) {
14543                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14544                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14545                                 i);
14546                 ret = rte_vdev_init(vdev_name, NULL);
14547
14548                 TEST_ASSERT(ret == 0,
14549                         "Failed to create instance %u of"
14550                         " pmd : %s",
14551                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14552
14553                 if (ret < 0) {
14554                         RTE_LOG(ERR, USER1,
14555                                 "Failed to create 2 AESNI MB PMDs.\n");
14556                         return TEST_SKIPPED;
14557                 }
14558         }
14559
14560         /* attach 2 AESNI_MB cdevs */
14561         for (i = count; i < count + 2; i++) {
14562                 struct rte_cryptodev_info info;
14563                 unsigned int session_size;
14564
14565                 rte_cryptodev_info_get(i, &info);
14566                 if (info.driver_id != rte_cryptodev_driver_id_get(
14567                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14568                         continue;
14569
14570                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14571                 /*
14572                  * Create the session mempool again, since now there are new devices
14573                  * to use the mempool.
14574                  */
14575                 if (ts_params->session_mpool) {
14576                         rte_mempool_free(ts_params->session_mpool);
14577                         ts_params->session_mpool = NULL;
14578                 }
14579                 if (ts_params->session_priv_mpool) {
14580                         rte_mempool_free(ts_params->session_priv_mpool);
14581                         ts_params->session_priv_mpool = NULL;
14582                 }
14583
14584                 if (info.sym.max_nb_sessions != 0 &&
14585                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14586                         RTE_LOG(ERR, USER1,
14587                                         "Device does not support "
14588                                         "at least %u sessions\n",
14589                                         MAX_NB_SESSIONS);
14590                         return TEST_FAILED;
14591                 }
14592                 /*
14593                  * Create mempool with maximum number of sessions,
14594                  * to include the session headers
14595                  */
14596                 if (ts_params->session_mpool == NULL) {
14597                         ts_params->session_mpool =
14598                                 rte_cryptodev_sym_session_pool_create(
14599                                                 "test_sess_mp",
14600                                                 MAX_NB_SESSIONS, 0, 0, 0,
14601                                                 SOCKET_ID_ANY);
14602                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14603                                         "session mempool allocation failed");
14604                 }
14605
14606                 /*
14607                  * Create mempool with maximum number of sessions,
14608                  * to include device specific session private data
14609                  */
14610                 if (ts_params->session_priv_mpool == NULL) {
14611                         ts_params->session_priv_mpool = rte_mempool_create(
14612                                         "test_sess_mp_priv",
14613                                         MAX_NB_SESSIONS,
14614                                         session_size,
14615                                         0, 0, NULL, NULL, NULL,
14616                                         NULL, SOCKET_ID_ANY,
14617                                         0);
14618
14619                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14620                                         "session mempool allocation failed");
14621                 }
14622
14623                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14624                 ts_params->qp_conf.mp_session_private =
14625                                 ts_params->session_priv_mpool;
14626
14627                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14628                                 (uint8_t)i);
14629
14630                 TEST_ASSERT(ret == 0,
14631                         "Failed to attach device %u of pmd : %s", i,
14632                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14633
14634                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14635
14636                 nb_devs_attached++;
14637         }
14638
14639         return 0;
14640 }
14641
14642 static int
14643 test_scheduler_detach_worker_op(void)
14644 {
14645         struct crypto_testsuite_params *ts_params = &testsuite_params;
14646         uint8_t sched_id = ts_params->valid_devs[0];
14647         uint32_t i;
14648         int ret;
14649
14650         for (i = 0; i < 2; i++) {
14651                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14652                                 aesni_ids[i]);
14653                 TEST_ASSERT(ret == 0,
14654                         "Failed to detach device %u", aesni_ids[i]);
14655         }
14656
14657         return 0;
14658 }
14659
14660 static int
14661 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14662 {
14663         struct crypto_testsuite_params *ts_params = &testsuite_params;
14664         uint8_t sched_id = ts_params->valid_devs[0];
14665         /* set mode */
14666         return rte_cryptodev_scheduler_mode_set(sched_id,
14667                 scheduler_mode);
14668 }
14669
14670 static int
14671 test_scheduler_mode_roundrobin_op(void)
14672 {
14673         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14674                         0, "Failed to set roundrobin mode");
14675         return 0;
14676
14677 }
14678
14679 static int
14680 test_scheduler_mode_multicore_op(void)
14681 {
14682         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14683                         0, "Failed to set multicore mode");
14684
14685         return 0;
14686 }
14687
14688 static int
14689 test_scheduler_mode_failover_op(void)
14690 {
14691         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14692                         0, "Failed to set failover mode");
14693
14694         return 0;
14695 }
14696
14697 static int
14698 test_scheduler_mode_pkt_size_distr_op(void)
14699 {
14700         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14701                         0, "Failed to set pktsize mode");
14702
14703         return 0;
14704 }
14705
14706 static int
14707 scheduler_multicore_testsuite_setup(void)
14708 {
14709         if (test_scheduler_attach_worker_op() < 0)
14710                 return TEST_SKIPPED;
14711         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14712                 return TEST_SKIPPED;
14713         return 0;
14714 }
14715
14716 static int
14717 scheduler_roundrobin_testsuite_setup(void)
14718 {
14719         if (test_scheduler_attach_worker_op() < 0)
14720                 return TEST_SKIPPED;
14721         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
14722                 return TEST_SKIPPED;
14723         return 0;
14724 }
14725
14726 static int
14727 scheduler_failover_testsuite_setup(void)
14728 {
14729         if (test_scheduler_attach_worker_op() < 0)
14730                 return TEST_SKIPPED;
14731         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
14732                 return TEST_SKIPPED;
14733         return 0;
14734 }
14735
14736 static int
14737 scheduler_pkt_size_distr_testsuite_setup(void)
14738 {
14739         if (test_scheduler_attach_worker_op() < 0)
14740                 return TEST_SKIPPED;
14741         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
14742                 return TEST_SKIPPED;
14743         return 0;
14744 }
14745
14746 static void
14747 scheduler_mode_testsuite_teardown(void)
14748 {
14749         test_scheduler_detach_worker_op();
14750 }
14751
14752 #endif /* RTE_CRYPTO_SCHEDULER */
14753
14754 static struct unit_test_suite end_testsuite = {
14755         .suite_name = NULL,
14756         .setup = NULL,
14757         .teardown = NULL,
14758         .unit_test_suites = NULL
14759 };
14760
14761 #ifdef RTE_LIB_SECURITY
14762 static struct unit_test_suite ipsec_proto_testsuite  = {
14763         .suite_name = "IPsec Proto Unit Test Suite",
14764         .setup = ipsec_proto_testsuite_setup,
14765         .unit_test_cases = {
14766                 TEST_CASE_NAMED_WITH_DATA(
14767                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14768                         ut_setup_security, ut_teardown,
14769                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
14770                 TEST_CASE_NAMED_WITH_DATA(
14771                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14772                         ut_setup_security, ut_teardown,
14773                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
14774                 TEST_CASE_NAMED_WITH_DATA(
14775                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14776                         ut_setup_security, ut_teardown,
14777                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
14778                 TEST_CASE_NAMED_WITH_DATA(
14779                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14780                         ut_setup_security, ut_teardown,
14781                         test_ipsec_proto_known_vec,
14782                         &pkt_aes_128_cbc_hmac_sha256),
14783                 TEST_CASE_NAMED_WITH_DATA(
14784                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14785                         ut_setup_security, ut_teardown,
14786                         test_ipsec_proto_known_vec,
14787                         &pkt_aes_128_cbc_hmac_sha384),
14788                 TEST_CASE_NAMED_WITH_DATA(
14789                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14790                         ut_setup_security, ut_teardown,
14791                         test_ipsec_proto_known_vec,
14792                         &pkt_aes_128_cbc_hmac_sha512),
14793                 TEST_CASE_NAMED_WITH_DATA(
14794                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14795                         ut_setup_security, ut_teardown,
14796                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
14797                 TEST_CASE_NAMED_WITH_DATA(
14798                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14799                         ut_setup_security, ut_teardown,
14800                         test_ipsec_proto_known_vec,
14801                         &pkt_aes_128_cbc_hmac_sha256_v6),
14802                 TEST_CASE_NAMED_WITH_DATA(
14803                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14804                         ut_setup_security, ut_teardown,
14805                         test_ipsec_proto_known_vec,
14806                         &pkt_null_aes_xcbc),
14807                 TEST_CASE_NAMED_WITH_DATA(
14808                         "Outbound fragmented packet",
14809                         ut_setup_security, ut_teardown,
14810                         test_ipsec_proto_known_vec_fragmented,
14811                         &pkt_aes_128_gcm_frag),
14812                 TEST_CASE_NAMED_WITH_DATA(
14813                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
14814                         ut_setup_security, ut_teardown,
14815                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
14816                 TEST_CASE_NAMED_WITH_DATA(
14817                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
14818                         ut_setup_security, ut_teardown,
14819                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
14820                 TEST_CASE_NAMED_WITH_DATA(
14821                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
14822                         ut_setup_security, ut_teardown,
14823                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
14824                 TEST_CASE_NAMED_WITH_DATA(
14825                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
14826                         ut_setup_security, ut_teardown,
14827                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
14828                 TEST_CASE_NAMED_WITH_DATA(
14829                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14830                         ut_setup_security, ut_teardown,
14831                         test_ipsec_proto_known_vec_inb,
14832                         &pkt_aes_128_cbc_hmac_sha256),
14833                 TEST_CASE_NAMED_WITH_DATA(
14834                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
14835                         ut_setup_security, ut_teardown,
14836                         test_ipsec_proto_known_vec_inb,
14837                         &pkt_aes_128_cbc_hmac_sha384),
14838                 TEST_CASE_NAMED_WITH_DATA(
14839                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
14840                         ut_setup_security, ut_teardown,
14841                         test_ipsec_proto_known_vec_inb,
14842                         &pkt_aes_128_cbc_hmac_sha512),
14843                 TEST_CASE_NAMED_WITH_DATA(
14844                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
14845                         ut_setup_security, ut_teardown,
14846                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
14847                 TEST_CASE_NAMED_WITH_DATA(
14848                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
14849                         ut_setup_security, ut_teardown,
14850                         test_ipsec_proto_known_vec_inb,
14851                         &pkt_aes_128_cbc_hmac_sha256_v6),
14852                 TEST_CASE_NAMED_WITH_DATA(
14853                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
14854                         ut_setup_security, ut_teardown,
14855                         test_ipsec_proto_known_vec_inb,
14856                         &pkt_null_aes_xcbc),
14857                 TEST_CASE_NAMED_ST(
14858                         "Combined test alg list",
14859                         ut_setup_security, ut_teardown,
14860                         test_ipsec_proto_display_list),
14861                 TEST_CASE_NAMED_ST(
14862                         "IV generation",
14863                         ut_setup_security, ut_teardown,
14864                         test_ipsec_proto_iv_gen),
14865                 TEST_CASE_NAMED_ST(
14866                         "UDP encapsulation",
14867                         ut_setup_security, ut_teardown,
14868                         test_ipsec_proto_udp_encap),
14869                 TEST_CASE_NAMED_ST(
14870                         "UDP encapsulation ports verification test",
14871                         ut_setup_security, ut_teardown,
14872                         test_ipsec_proto_udp_ports_verify),
14873                 TEST_CASE_NAMED_ST(
14874                         "SA expiry packets soft",
14875                         ut_setup_security, ut_teardown,
14876                         test_ipsec_proto_sa_exp_pkts_soft),
14877                 TEST_CASE_NAMED_ST(
14878                         "SA expiry packets hard",
14879                         ut_setup_security, ut_teardown,
14880                         test_ipsec_proto_sa_exp_pkts_hard),
14881                 TEST_CASE_NAMED_ST(
14882                         "Negative test: ICV corruption",
14883                         ut_setup_security, ut_teardown,
14884                         test_ipsec_proto_err_icv_corrupt),
14885                 TEST_CASE_NAMED_ST(
14886                         "Tunnel dst addr verification",
14887                         ut_setup_security, ut_teardown,
14888                         test_ipsec_proto_tunnel_dst_addr_verify),
14889                 TEST_CASE_NAMED_ST(
14890                         "Tunnel src and dst addr verification",
14891                         ut_setup_security, ut_teardown,
14892                         test_ipsec_proto_tunnel_src_dst_addr_verify),
14893                 TEST_CASE_NAMED_ST(
14894                         "Inner IP checksum",
14895                         ut_setup_security, ut_teardown,
14896                         test_ipsec_proto_inner_ip_csum),
14897                 TEST_CASE_NAMED_ST(
14898                         "Inner L4 checksum",
14899                         ut_setup_security, ut_teardown,
14900                         test_ipsec_proto_inner_l4_csum),
14901                 TEST_CASE_NAMED_ST(
14902                         "Tunnel IPv4 in IPv4",
14903                         ut_setup_security, ut_teardown,
14904                         test_ipsec_proto_tunnel_v4_in_v4),
14905                 TEST_CASE_NAMED_ST(
14906                         "Tunnel IPv6 in IPv6",
14907                         ut_setup_security, ut_teardown,
14908                         test_ipsec_proto_tunnel_v6_in_v6),
14909                 TEST_CASE_NAMED_ST(
14910                         "Tunnel IPv4 in IPv6",
14911                         ut_setup_security, ut_teardown,
14912                         test_ipsec_proto_tunnel_v4_in_v6),
14913                 TEST_CASE_NAMED_ST(
14914                         "Tunnel IPv6 in IPv4",
14915                         ut_setup_security, ut_teardown,
14916                         test_ipsec_proto_tunnel_v6_in_v4),
14917                 TEST_CASE_NAMED_ST(
14918                         "Transport IPv4",
14919                         ut_setup_security, ut_teardown,
14920                         test_ipsec_proto_transport_v4),
14921                 TEST_CASE_NAMED_ST(
14922                         "Statistics: success",
14923                         ut_setup_security, ut_teardown,
14924                         test_ipsec_proto_stats),
14925                 TEST_CASE_NAMED_ST(
14926                         "Fragmented packet",
14927                         ut_setup_security, ut_teardown,
14928                         test_ipsec_proto_pkt_fragment),
14929                 TEST_CASE_NAMED_ST(
14930                         "Tunnel header copy DF (inner 0)",
14931                         ut_setup_security, ut_teardown,
14932                         test_ipsec_proto_copy_df_inner_0),
14933                 TEST_CASE_NAMED_ST(
14934                         "Tunnel header copy DF (inner 1)",
14935                         ut_setup_security, ut_teardown,
14936                         test_ipsec_proto_copy_df_inner_1),
14937                 TEST_CASE_NAMED_ST(
14938                         "Tunnel header set DF 0 (inner 1)",
14939                         ut_setup_security, ut_teardown,
14940                         test_ipsec_proto_set_df_0_inner_1),
14941                 TEST_CASE_NAMED_ST(
14942                         "Tunnel header set DF 1 (inner 0)",
14943                         ut_setup_security, ut_teardown,
14944                         test_ipsec_proto_set_df_1_inner_0),
14945                 TEST_CASE_NAMED_ST(
14946                         "Tunnel header IPv4 copy DSCP (inner 0)",
14947                         ut_setup_security, ut_teardown,
14948                         test_ipsec_proto_ipv4_copy_dscp_inner_0),
14949                 TEST_CASE_NAMED_ST(
14950                         "Tunnel header IPv4 copy DSCP (inner 1)",
14951                         ut_setup_security, ut_teardown,
14952                         test_ipsec_proto_ipv4_copy_dscp_inner_1),
14953                 TEST_CASE_NAMED_ST(
14954                         "Tunnel header IPv4 set DSCP 0 (inner 1)",
14955                         ut_setup_security, ut_teardown,
14956                         test_ipsec_proto_ipv4_set_dscp_0_inner_1),
14957                 TEST_CASE_NAMED_ST(
14958                         "Tunnel header IPv4 set DSCP 1 (inner 0)",
14959                         ut_setup_security, ut_teardown,
14960                         test_ipsec_proto_ipv4_set_dscp_1_inner_0),
14961                 TEST_CASE_NAMED_ST(
14962                         "Tunnel header IPv6 copy DSCP (inner 0)",
14963                         ut_setup_security, ut_teardown,
14964                         test_ipsec_proto_ipv6_copy_dscp_inner_0),
14965                 TEST_CASE_NAMED_ST(
14966                         "Tunnel header IPv6 copy DSCP (inner 1)",
14967                         ut_setup_security, ut_teardown,
14968                         test_ipsec_proto_ipv6_copy_dscp_inner_1),
14969                 TEST_CASE_NAMED_ST(
14970                         "Tunnel header IPv6 set DSCP 0 (inner 1)",
14971                         ut_setup_security, ut_teardown,
14972                         test_ipsec_proto_ipv6_set_dscp_0_inner_1),
14973                 TEST_CASE_NAMED_ST(
14974                         "Tunnel header IPv6 set DSCP 1 (inner 0)",
14975                         ut_setup_security, ut_teardown,
14976                         test_ipsec_proto_ipv6_set_dscp_1_inner_0),
14977                 TEST_CASES_END() /**< NULL terminate unit test array */
14978         }
14979 };
14980
14981 static struct unit_test_suite pdcp_proto_testsuite  = {
14982         .suite_name = "PDCP Proto Unit Test Suite",
14983         .setup = pdcp_proto_testsuite_setup,
14984         .unit_test_cases = {
14985                 TEST_CASE_ST(ut_setup_security, ut_teardown,
14986                         test_PDCP_PROTO_all),
14987                 TEST_CASES_END() /**< NULL terminate unit test array */
14988         }
14989 };
14990
14991 #define ADD_UPLINK_TESTCASE(data)                                               \
14992         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
14993         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
14994
14995 #define ADD_DOWNLINK_TESTCASE(data)                                             \
14996         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
14997         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
14998
14999 static struct unit_test_suite docsis_proto_testsuite  = {
15000         .suite_name = "DOCSIS Proto Unit Test Suite",
15001         .setup = docsis_proto_testsuite_setup,
15002         .unit_test_cases = {
15003                 /* Uplink */
15004                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
15005                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
15006                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
15007                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
15008                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
15009                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
15010                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
15011                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
15012                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
15013                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
15014                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
15015                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
15016                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
15017                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
15018                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
15019                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
15020                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
15021                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
15022                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
15023                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
15024                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
15025                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
15026                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
15027                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
15028                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
15029                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
15030                 /* Downlink */
15031                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
15032                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
15033                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
15034                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
15035                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
15036                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
15037                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
15038                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
15039                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
15040                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
15041                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
15042                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
15043                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
15044                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
15045                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
15046                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
15047                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
15048                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
15049                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
15050                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
15051                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
15052                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
15053                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
15054                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
15055                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
15056                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
15057                 TEST_CASES_END() /**< NULL terminate unit test array */
15058         }
15059 };
15060 #endif
15061
15062 static struct unit_test_suite cryptodev_gen_testsuite  = {
15063         .suite_name = "Crypto General Unit Test Suite",
15064         .setup = crypto_gen_testsuite_setup,
15065         .unit_test_cases = {
15066                 TEST_CASE_ST(ut_setup, ut_teardown,
15067                                 test_device_configure_invalid_dev_id),
15068                 TEST_CASE_ST(ut_setup, ut_teardown,
15069                                 test_queue_pair_descriptor_setup),
15070                 TEST_CASE_ST(ut_setup, ut_teardown,
15071                                 test_device_configure_invalid_queue_pair_ids),
15072                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
15073                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
15074                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
15075                 TEST_CASES_END() /**< NULL terminate unit test array */
15076         }
15077 };
15078
15079 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
15080         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
15081         .setup = negative_hmac_sha1_testsuite_setup,
15082         .unit_test_cases = {
15083                 /** Negative tests */
15084                 TEST_CASE_ST(ut_setup, ut_teardown,
15085                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
15086                 TEST_CASE_ST(ut_setup, ut_teardown,
15087                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
15088                 TEST_CASE_ST(ut_setup, ut_teardown,
15089                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
15090                 TEST_CASE_ST(ut_setup, ut_teardown,
15091                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
15092
15093                 TEST_CASES_END() /**< NULL terminate unit test array */
15094         }
15095 };
15096
15097 static struct unit_test_suite cryptodev_multi_session_testsuite = {
15098         .suite_name = "Multi Session Unit Test Suite",
15099         .setup = multi_session_testsuite_setup,
15100         .unit_test_cases = {
15101                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
15102                 TEST_CASE_ST(ut_setup, ut_teardown,
15103                                 test_multi_session_random_usage),
15104
15105                 TEST_CASES_END() /**< NULL terminate unit test array */
15106         }
15107 };
15108
15109 static struct unit_test_suite cryptodev_null_testsuite  = {
15110         .suite_name = "NULL Test Suite",
15111         .setup = null_testsuite_setup,
15112         .unit_test_cases = {
15113                 TEST_CASE_ST(ut_setup, ut_teardown,
15114                         test_null_invalid_operation),
15115                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
15116                 TEST_CASES_END()
15117         }
15118 };
15119
15120 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
15121         .suite_name = "AES CCM Authenticated Test Suite",
15122         .setup = aes_ccm_auth_testsuite_setup,
15123         .unit_test_cases = {
15124                 /** AES CCM Authenticated Encryption 128 bits key*/
15125                 TEST_CASE_ST(ut_setup, ut_teardown,
15126                         test_AES_CCM_authenticated_encryption_test_case_128_1),
15127                 TEST_CASE_ST(ut_setup, ut_teardown,
15128                         test_AES_CCM_authenticated_encryption_test_case_128_2),
15129                 TEST_CASE_ST(ut_setup, ut_teardown,
15130                         test_AES_CCM_authenticated_encryption_test_case_128_3),
15131
15132                 /** AES CCM Authenticated Decryption 128 bits key*/
15133                 TEST_CASE_ST(ut_setup, ut_teardown,
15134                         test_AES_CCM_authenticated_decryption_test_case_128_1),
15135                 TEST_CASE_ST(ut_setup, ut_teardown,
15136                         test_AES_CCM_authenticated_decryption_test_case_128_2),
15137                 TEST_CASE_ST(ut_setup, ut_teardown,
15138                         test_AES_CCM_authenticated_decryption_test_case_128_3),
15139
15140                 /** AES CCM Authenticated Encryption 192 bits key */
15141                 TEST_CASE_ST(ut_setup, ut_teardown,
15142                         test_AES_CCM_authenticated_encryption_test_case_192_1),
15143                 TEST_CASE_ST(ut_setup, ut_teardown,
15144                         test_AES_CCM_authenticated_encryption_test_case_192_2),
15145                 TEST_CASE_ST(ut_setup, ut_teardown,
15146                         test_AES_CCM_authenticated_encryption_test_case_192_3),
15147
15148                 /** AES CCM Authenticated Decryption 192 bits key*/
15149                 TEST_CASE_ST(ut_setup, ut_teardown,
15150                         test_AES_CCM_authenticated_decryption_test_case_192_1),
15151                 TEST_CASE_ST(ut_setup, ut_teardown,
15152                         test_AES_CCM_authenticated_decryption_test_case_192_2),
15153                 TEST_CASE_ST(ut_setup, ut_teardown,
15154                         test_AES_CCM_authenticated_decryption_test_case_192_3),
15155
15156                 /** AES CCM Authenticated Encryption 256 bits key */
15157                 TEST_CASE_ST(ut_setup, ut_teardown,
15158                         test_AES_CCM_authenticated_encryption_test_case_256_1),
15159                 TEST_CASE_ST(ut_setup, ut_teardown,
15160                         test_AES_CCM_authenticated_encryption_test_case_256_2),
15161                 TEST_CASE_ST(ut_setup, ut_teardown,
15162                         test_AES_CCM_authenticated_encryption_test_case_256_3),
15163
15164                 /** AES CCM Authenticated Decryption 256 bits key*/
15165                 TEST_CASE_ST(ut_setup, ut_teardown,
15166                         test_AES_CCM_authenticated_decryption_test_case_256_1),
15167                 TEST_CASE_ST(ut_setup, ut_teardown,
15168                         test_AES_CCM_authenticated_decryption_test_case_256_2),
15169                 TEST_CASE_ST(ut_setup, ut_teardown,
15170                         test_AES_CCM_authenticated_decryption_test_case_256_3),
15171                 TEST_CASES_END()
15172         }
15173 };
15174
15175 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
15176         .suite_name = "AES GCM Authenticated Test Suite",
15177         .setup = aes_gcm_auth_testsuite_setup,
15178         .unit_test_cases = {
15179                 /** AES GCM Authenticated Encryption */
15180                 TEST_CASE_ST(ut_setup, ut_teardown,
15181                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
15182                 TEST_CASE_ST(ut_setup, ut_teardown,
15183                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
15184                 TEST_CASE_ST(ut_setup, ut_teardown,
15185                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
15186                 TEST_CASE_ST(ut_setup, ut_teardown,
15187                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
15188                 TEST_CASE_ST(ut_setup, ut_teardown,
15189                         test_AES_GCM_authenticated_encryption_test_case_1),
15190                 TEST_CASE_ST(ut_setup, ut_teardown,
15191                         test_AES_GCM_authenticated_encryption_test_case_2),
15192                 TEST_CASE_ST(ut_setup, ut_teardown,
15193                         test_AES_GCM_authenticated_encryption_test_case_3),
15194                 TEST_CASE_ST(ut_setup, ut_teardown,
15195                         test_AES_GCM_authenticated_encryption_test_case_4),
15196                 TEST_CASE_ST(ut_setup, ut_teardown,
15197                         test_AES_GCM_authenticated_encryption_test_case_5),
15198                 TEST_CASE_ST(ut_setup, ut_teardown,
15199                         test_AES_GCM_authenticated_encryption_test_case_6),
15200                 TEST_CASE_ST(ut_setup, ut_teardown,
15201                         test_AES_GCM_authenticated_encryption_test_case_7),
15202                 TEST_CASE_ST(ut_setup, ut_teardown,
15203                         test_AES_GCM_authenticated_encryption_test_case_8),
15204                 TEST_CASE_ST(ut_setup, ut_teardown,
15205                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
15206
15207                 /** AES GCM Authenticated Decryption */
15208                 TEST_CASE_ST(ut_setup, ut_teardown,
15209                         test_AES_GCM_authenticated_decryption_test_case_1),
15210                 TEST_CASE_ST(ut_setup, ut_teardown,
15211                         test_AES_GCM_authenticated_decryption_test_case_2),
15212                 TEST_CASE_ST(ut_setup, ut_teardown,
15213                         test_AES_GCM_authenticated_decryption_test_case_3),
15214                 TEST_CASE_ST(ut_setup, ut_teardown,
15215                         test_AES_GCM_authenticated_decryption_test_case_4),
15216                 TEST_CASE_ST(ut_setup, ut_teardown,
15217                         test_AES_GCM_authenticated_decryption_test_case_5),
15218                 TEST_CASE_ST(ut_setup, ut_teardown,
15219                         test_AES_GCM_authenticated_decryption_test_case_6),
15220                 TEST_CASE_ST(ut_setup, ut_teardown,
15221                         test_AES_GCM_authenticated_decryption_test_case_7),
15222                 TEST_CASE_ST(ut_setup, ut_teardown,
15223                         test_AES_GCM_authenticated_decryption_test_case_8),
15224                 TEST_CASE_ST(ut_setup, ut_teardown,
15225                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
15226
15227                 /** AES GCM Authenticated Encryption 192 bits key */
15228                 TEST_CASE_ST(ut_setup, ut_teardown,
15229                         test_AES_GCM_auth_encryption_test_case_192_1),
15230                 TEST_CASE_ST(ut_setup, ut_teardown,
15231                         test_AES_GCM_auth_encryption_test_case_192_2),
15232                 TEST_CASE_ST(ut_setup, ut_teardown,
15233                         test_AES_GCM_auth_encryption_test_case_192_3),
15234                 TEST_CASE_ST(ut_setup, ut_teardown,
15235                         test_AES_GCM_auth_encryption_test_case_192_4),
15236                 TEST_CASE_ST(ut_setup, ut_teardown,
15237                         test_AES_GCM_auth_encryption_test_case_192_5),
15238                 TEST_CASE_ST(ut_setup, ut_teardown,
15239                         test_AES_GCM_auth_encryption_test_case_192_6),
15240                 TEST_CASE_ST(ut_setup, ut_teardown,
15241                         test_AES_GCM_auth_encryption_test_case_192_7),
15242
15243                 /** AES GCM Authenticated Decryption 192 bits key */
15244                 TEST_CASE_ST(ut_setup, ut_teardown,
15245                         test_AES_GCM_auth_decryption_test_case_192_1),
15246                 TEST_CASE_ST(ut_setup, ut_teardown,
15247                         test_AES_GCM_auth_decryption_test_case_192_2),
15248                 TEST_CASE_ST(ut_setup, ut_teardown,
15249                         test_AES_GCM_auth_decryption_test_case_192_3),
15250                 TEST_CASE_ST(ut_setup, ut_teardown,
15251                         test_AES_GCM_auth_decryption_test_case_192_4),
15252                 TEST_CASE_ST(ut_setup, ut_teardown,
15253                         test_AES_GCM_auth_decryption_test_case_192_5),
15254                 TEST_CASE_ST(ut_setup, ut_teardown,
15255                         test_AES_GCM_auth_decryption_test_case_192_6),
15256                 TEST_CASE_ST(ut_setup, ut_teardown,
15257                         test_AES_GCM_auth_decryption_test_case_192_7),
15258
15259                 /** AES GCM Authenticated Encryption 256 bits key */
15260                 TEST_CASE_ST(ut_setup, ut_teardown,
15261                         test_AES_GCM_auth_encryption_test_case_256_1),
15262                 TEST_CASE_ST(ut_setup, ut_teardown,
15263                         test_AES_GCM_auth_encryption_test_case_256_2),
15264                 TEST_CASE_ST(ut_setup, ut_teardown,
15265                         test_AES_GCM_auth_encryption_test_case_256_3),
15266                 TEST_CASE_ST(ut_setup, ut_teardown,
15267                         test_AES_GCM_auth_encryption_test_case_256_4),
15268                 TEST_CASE_ST(ut_setup, ut_teardown,
15269                         test_AES_GCM_auth_encryption_test_case_256_5),
15270                 TEST_CASE_ST(ut_setup, ut_teardown,
15271                         test_AES_GCM_auth_encryption_test_case_256_6),
15272                 TEST_CASE_ST(ut_setup, ut_teardown,
15273                         test_AES_GCM_auth_encryption_test_case_256_7),
15274
15275                 /** AES GCM Authenticated Decryption 256 bits key */
15276                 TEST_CASE_ST(ut_setup, ut_teardown,
15277                         test_AES_GCM_auth_decryption_test_case_256_1),
15278                 TEST_CASE_ST(ut_setup, ut_teardown,
15279                         test_AES_GCM_auth_decryption_test_case_256_2),
15280                 TEST_CASE_ST(ut_setup, ut_teardown,
15281                         test_AES_GCM_auth_decryption_test_case_256_3),
15282                 TEST_CASE_ST(ut_setup, ut_teardown,
15283                         test_AES_GCM_auth_decryption_test_case_256_4),
15284                 TEST_CASE_ST(ut_setup, ut_teardown,
15285                         test_AES_GCM_auth_decryption_test_case_256_5),
15286                 TEST_CASE_ST(ut_setup, ut_teardown,
15287                         test_AES_GCM_auth_decryption_test_case_256_6),
15288                 TEST_CASE_ST(ut_setup, ut_teardown,
15289                         test_AES_GCM_auth_decryption_test_case_256_7),
15290
15291                 /** AES GCM Authenticated Encryption big aad size */
15292                 TEST_CASE_ST(ut_setup, ut_teardown,
15293                         test_AES_GCM_auth_encryption_test_case_aad_1),
15294                 TEST_CASE_ST(ut_setup, ut_teardown,
15295                         test_AES_GCM_auth_encryption_test_case_aad_2),
15296
15297                 /** AES GCM Authenticated Decryption big aad size */
15298                 TEST_CASE_ST(ut_setup, ut_teardown,
15299                         test_AES_GCM_auth_decryption_test_case_aad_1),
15300                 TEST_CASE_ST(ut_setup, ut_teardown,
15301                         test_AES_GCM_auth_decryption_test_case_aad_2),
15302
15303                 /** Out of place tests */
15304                 TEST_CASE_ST(ut_setup, ut_teardown,
15305                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15306                 TEST_CASE_ST(ut_setup, ut_teardown,
15307                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15308
15309                 /** Session-less tests */
15310                 TEST_CASE_ST(ut_setup, ut_teardown,
15311                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15312                 TEST_CASE_ST(ut_setup, ut_teardown,
15313                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15314
15315                 TEST_CASES_END()
15316         }
15317 };
15318
15319 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15320         .suite_name = "AES GMAC Authentication Test Suite",
15321         .setup = aes_gmac_auth_testsuite_setup,
15322         .unit_test_cases = {
15323                 TEST_CASE_ST(ut_setup, ut_teardown,
15324                         test_AES_GMAC_authentication_test_case_1),
15325                 TEST_CASE_ST(ut_setup, ut_teardown,
15326                         test_AES_GMAC_authentication_verify_test_case_1),
15327                 TEST_CASE_ST(ut_setup, ut_teardown,
15328                         test_AES_GMAC_authentication_test_case_2),
15329                 TEST_CASE_ST(ut_setup, ut_teardown,
15330                         test_AES_GMAC_authentication_verify_test_case_2),
15331                 TEST_CASE_ST(ut_setup, ut_teardown,
15332                         test_AES_GMAC_authentication_test_case_3),
15333                 TEST_CASE_ST(ut_setup, ut_teardown,
15334                         test_AES_GMAC_authentication_verify_test_case_3),
15335                 TEST_CASE_ST(ut_setup, ut_teardown,
15336                         test_AES_GMAC_authentication_test_case_4),
15337                 TEST_CASE_ST(ut_setup, ut_teardown,
15338                         test_AES_GMAC_authentication_verify_test_case_4),
15339                 TEST_CASE_ST(ut_setup, ut_teardown,
15340                         test_AES_GMAC_authentication_SGL_40B),
15341                 TEST_CASE_ST(ut_setup, ut_teardown,
15342                         test_AES_GMAC_authentication_SGL_80B),
15343                 TEST_CASE_ST(ut_setup, ut_teardown,
15344                         test_AES_GMAC_authentication_SGL_2048B),
15345                 TEST_CASE_ST(ut_setup, ut_teardown,
15346                         test_AES_GMAC_authentication_SGL_2047B),
15347
15348                 TEST_CASES_END()
15349         }
15350 };
15351
15352 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15353         .suite_name = "Chacha20-Poly1305 Test Suite",
15354         .setup = chacha20_poly1305_testsuite_setup,
15355         .unit_test_cases = {
15356                 TEST_CASE_ST(ut_setup, ut_teardown,
15357                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15358                 TEST_CASE_ST(ut_setup, ut_teardown,
15359                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15360                 TEST_CASE_ST(ut_setup, ut_teardown,
15361                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15362                 TEST_CASES_END()
15363         }
15364 };
15365
15366 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15367         .suite_name = "SNOW 3G Test Suite",
15368         .setup = snow3g_testsuite_setup,
15369         .unit_test_cases = {
15370                 /** SNOW 3G encrypt only (UEA2) */
15371                 TEST_CASE_ST(ut_setup, ut_teardown,
15372                         test_snow3g_encryption_test_case_1),
15373                 TEST_CASE_ST(ut_setup, ut_teardown,
15374                         test_snow3g_encryption_test_case_2),
15375                 TEST_CASE_ST(ut_setup, ut_teardown,
15376                         test_snow3g_encryption_test_case_3),
15377                 TEST_CASE_ST(ut_setup, ut_teardown,
15378                         test_snow3g_encryption_test_case_4),
15379                 TEST_CASE_ST(ut_setup, ut_teardown,
15380                         test_snow3g_encryption_test_case_5),
15381
15382                 TEST_CASE_ST(ut_setup, ut_teardown,
15383                         test_snow3g_encryption_test_case_1_oop),
15384                 TEST_CASE_ST(ut_setup, ut_teardown,
15385                         test_snow3g_encryption_test_case_1_oop_sgl),
15386                 TEST_CASE_ST(ut_setup, ut_teardown,
15387                         test_snow3g_encryption_test_case_1_offset_oop),
15388                 TEST_CASE_ST(ut_setup, ut_teardown,
15389                         test_snow3g_decryption_test_case_1_oop),
15390
15391                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15392                 TEST_CASE_ST(ut_setup, ut_teardown,
15393                         test_snow3g_auth_cipher_test_case_1),
15394                 TEST_CASE_ST(ut_setup, ut_teardown,
15395                         test_snow3g_auth_cipher_test_case_2),
15396                 TEST_CASE_ST(ut_setup, ut_teardown,
15397                         test_snow3g_auth_cipher_test_case_2_oop),
15398                 TEST_CASE_ST(ut_setup, ut_teardown,
15399                         test_snow3g_auth_cipher_part_digest_enc),
15400                 TEST_CASE_ST(ut_setup, ut_teardown,
15401                         test_snow3g_auth_cipher_part_digest_enc_oop),
15402                 TEST_CASE_ST(ut_setup, ut_teardown,
15403                         test_snow3g_auth_cipher_test_case_3_sgl),
15404                 TEST_CASE_ST(ut_setup, ut_teardown,
15405                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15406                 TEST_CASE_ST(ut_setup, ut_teardown,
15407                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15408                 TEST_CASE_ST(ut_setup, ut_teardown,
15409                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15410
15411                 /** SNOW 3G decrypt (UEA2), then verify auth */
15412                 TEST_CASE_ST(ut_setup, ut_teardown,
15413                         test_snow3g_auth_cipher_verify_test_case_1),
15414                 TEST_CASE_ST(ut_setup, ut_teardown,
15415                         test_snow3g_auth_cipher_verify_test_case_2),
15416                 TEST_CASE_ST(ut_setup, ut_teardown,
15417                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15418                 TEST_CASE_ST(ut_setup, ut_teardown,
15419                         test_snow3g_auth_cipher_verify_part_digest_enc),
15420                 TEST_CASE_ST(ut_setup, ut_teardown,
15421                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15422                 TEST_CASE_ST(ut_setup, ut_teardown,
15423                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15424                 TEST_CASE_ST(ut_setup, ut_teardown,
15425                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15426                 TEST_CASE_ST(ut_setup, ut_teardown,
15427                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15428                 TEST_CASE_ST(ut_setup, ut_teardown,
15429                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15430
15431                 /** SNOW 3G decrypt only (UEA2) */
15432                 TEST_CASE_ST(ut_setup, ut_teardown,
15433                         test_snow3g_decryption_test_case_1),
15434                 TEST_CASE_ST(ut_setup, ut_teardown,
15435                         test_snow3g_decryption_test_case_2),
15436                 TEST_CASE_ST(ut_setup, ut_teardown,
15437                         test_snow3g_decryption_test_case_3),
15438                 TEST_CASE_ST(ut_setup, ut_teardown,
15439                         test_snow3g_decryption_test_case_4),
15440                 TEST_CASE_ST(ut_setup, ut_teardown,
15441                         test_snow3g_decryption_test_case_5),
15442                 TEST_CASE_ST(ut_setup, ut_teardown,
15443                         test_snow3g_decryption_with_digest_test_case_1),
15444                 TEST_CASE_ST(ut_setup, ut_teardown,
15445                         test_snow3g_hash_generate_test_case_1),
15446                 TEST_CASE_ST(ut_setup, ut_teardown,
15447                         test_snow3g_hash_generate_test_case_2),
15448                 TEST_CASE_ST(ut_setup, ut_teardown,
15449                         test_snow3g_hash_generate_test_case_3),
15450
15451                 /* Tests with buffers which length is not byte-aligned */
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                         test_snow3g_hash_generate_test_case_4),
15454                 TEST_CASE_ST(ut_setup, ut_teardown,
15455                         test_snow3g_hash_generate_test_case_5),
15456                 TEST_CASE_ST(ut_setup, ut_teardown,
15457                         test_snow3g_hash_generate_test_case_6),
15458                 TEST_CASE_ST(ut_setup, ut_teardown,
15459                         test_snow3g_hash_verify_test_case_1),
15460                 TEST_CASE_ST(ut_setup, ut_teardown,
15461                         test_snow3g_hash_verify_test_case_2),
15462                 TEST_CASE_ST(ut_setup, ut_teardown,
15463                         test_snow3g_hash_verify_test_case_3),
15464
15465                 /* Tests with buffers which length is not byte-aligned */
15466                 TEST_CASE_ST(ut_setup, ut_teardown,
15467                         test_snow3g_hash_verify_test_case_4),
15468                 TEST_CASE_ST(ut_setup, ut_teardown,
15469                         test_snow3g_hash_verify_test_case_5),
15470                 TEST_CASE_ST(ut_setup, ut_teardown,
15471                         test_snow3g_hash_verify_test_case_6),
15472                 TEST_CASE_ST(ut_setup, ut_teardown,
15473                         test_snow3g_cipher_auth_test_case_1),
15474                 TEST_CASE_ST(ut_setup, ut_teardown,
15475                         test_snow3g_auth_cipher_with_digest_test_case_1),
15476                 TEST_CASES_END()
15477         }
15478 };
15479
15480 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15481         .suite_name = "ZUC Test Suite",
15482         .setup = zuc_testsuite_setup,
15483         .unit_test_cases = {
15484                 /** ZUC encrypt only (EEA3) */
15485                 TEST_CASE_ST(ut_setup, ut_teardown,
15486                         test_zuc_encryption_test_case_1),
15487                 TEST_CASE_ST(ut_setup, ut_teardown,
15488                         test_zuc_encryption_test_case_2),
15489                 TEST_CASE_ST(ut_setup, ut_teardown,
15490                         test_zuc_encryption_test_case_3),
15491                 TEST_CASE_ST(ut_setup, ut_teardown,
15492                         test_zuc_encryption_test_case_4),
15493                 TEST_CASE_ST(ut_setup, ut_teardown,
15494                         test_zuc_encryption_test_case_5),
15495                 TEST_CASE_ST(ut_setup, ut_teardown,
15496                         test_zuc_encryption_test_case_6_sgl),
15497
15498                 /** ZUC authenticate (EIA3) */
15499                 TEST_CASE_ST(ut_setup, ut_teardown,
15500                         test_zuc_hash_generate_test_case_1),
15501                 TEST_CASE_ST(ut_setup, ut_teardown,
15502                         test_zuc_hash_generate_test_case_2),
15503                 TEST_CASE_ST(ut_setup, ut_teardown,
15504                         test_zuc_hash_generate_test_case_3),
15505                 TEST_CASE_ST(ut_setup, ut_teardown,
15506                         test_zuc_hash_generate_test_case_4),
15507                 TEST_CASE_ST(ut_setup, ut_teardown,
15508                         test_zuc_hash_generate_test_case_5),
15509                 TEST_CASE_ST(ut_setup, ut_teardown,
15510                         test_zuc_hash_generate_test_case_6),
15511                 TEST_CASE_ST(ut_setup, ut_teardown,
15512                         test_zuc_hash_generate_test_case_7),
15513                 TEST_CASE_ST(ut_setup, ut_teardown,
15514                         test_zuc_hash_generate_test_case_8),
15515                 TEST_CASE_ST(ut_setup, ut_teardown,
15516                         test_zuc_hash_generate_test_case_9),
15517                 TEST_CASE_ST(ut_setup, ut_teardown,
15518                         test_zuc_hash_generate_test_case_10),
15519                 TEST_CASE_ST(ut_setup, ut_teardown,
15520                         test_zuc_hash_generate_test_case_11),
15521
15522
15523                 /** ZUC alg-chain (EEA3/EIA3) */
15524                 TEST_CASE_ST(ut_setup, ut_teardown,
15525                         test_zuc_cipher_auth_test_case_1),
15526                 TEST_CASE_ST(ut_setup, ut_teardown,
15527                         test_zuc_cipher_auth_test_case_2),
15528
15529                 /** ZUC generate auth, then encrypt (EEA3) */
15530                 TEST_CASE_ST(ut_setup, ut_teardown,
15531                         test_zuc_auth_cipher_test_case_1),
15532                 TEST_CASE_ST(ut_setup, ut_teardown,
15533                         test_zuc_auth_cipher_test_case_1_oop),
15534                 TEST_CASE_ST(ut_setup, ut_teardown,
15535                         test_zuc_auth_cipher_test_case_1_sgl),
15536                 TEST_CASE_ST(ut_setup, ut_teardown,
15537                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15538
15539                 /** ZUC decrypt (EEA3), then verify auth */
15540                 TEST_CASE_ST(ut_setup, ut_teardown,
15541                         test_zuc_auth_cipher_verify_test_case_1),
15542                 TEST_CASE_ST(ut_setup, ut_teardown,
15543                         test_zuc_auth_cipher_verify_test_case_1_oop),
15544                 TEST_CASE_ST(ut_setup, ut_teardown,
15545                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15546                 TEST_CASE_ST(ut_setup, ut_teardown,
15547                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15548
15549                 /** ZUC-256 encrypt only **/
15550                 TEST_CASE_ST(ut_setup, ut_teardown,
15551                         test_zuc256_encryption_test_case_1),
15552                 TEST_CASE_ST(ut_setup, ut_teardown,
15553                         test_zuc256_encryption_test_case_2),
15554
15555                 /** ZUC-256 authentication only **/
15556                 TEST_CASE_ST(ut_setup, ut_teardown,
15557                         test_zuc256_authentication_test_case_1),
15558                 TEST_CASE_ST(ut_setup, ut_teardown,
15559                         test_zuc256_authentication_test_case_2),
15560
15561                 TEST_CASES_END()
15562         }
15563 };
15564
15565 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15566         .suite_name = "HMAC_MD5 Authentication Test Suite",
15567         .setup = hmac_md5_auth_testsuite_setup,
15568         .unit_test_cases = {
15569                 TEST_CASE_ST(ut_setup, ut_teardown,
15570                         test_MD5_HMAC_generate_case_1),
15571                 TEST_CASE_ST(ut_setup, ut_teardown,
15572                         test_MD5_HMAC_verify_case_1),
15573                 TEST_CASE_ST(ut_setup, ut_teardown,
15574                         test_MD5_HMAC_generate_case_2),
15575                 TEST_CASE_ST(ut_setup, ut_teardown,
15576                         test_MD5_HMAC_verify_case_2),
15577                 TEST_CASES_END()
15578         }
15579 };
15580
15581 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15582         .suite_name = "Kasumi Test Suite",
15583         .setup = kasumi_testsuite_setup,
15584         .unit_test_cases = {
15585                 /** KASUMI hash only (UIA1) */
15586                 TEST_CASE_ST(ut_setup, ut_teardown,
15587                         test_kasumi_hash_generate_test_case_1),
15588                 TEST_CASE_ST(ut_setup, ut_teardown,
15589                         test_kasumi_hash_generate_test_case_2),
15590                 TEST_CASE_ST(ut_setup, ut_teardown,
15591                         test_kasumi_hash_generate_test_case_3),
15592                 TEST_CASE_ST(ut_setup, ut_teardown,
15593                         test_kasumi_hash_generate_test_case_4),
15594                 TEST_CASE_ST(ut_setup, ut_teardown,
15595                         test_kasumi_hash_generate_test_case_5),
15596                 TEST_CASE_ST(ut_setup, ut_teardown,
15597                         test_kasumi_hash_generate_test_case_6),
15598
15599                 TEST_CASE_ST(ut_setup, ut_teardown,
15600                         test_kasumi_hash_verify_test_case_1),
15601                 TEST_CASE_ST(ut_setup, ut_teardown,
15602                         test_kasumi_hash_verify_test_case_2),
15603                 TEST_CASE_ST(ut_setup, ut_teardown,
15604                         test_kasumi_hash_verify_test_case_3),
15605                 TEST_CASE_ST(ut_setup, ut_teardown,
15606                         test_kasumi_hash_verify_test_case_4),
15607                 TEST_CASE_ST(ut_setup, ut_teardown,
15608                         test_kasumi_hash_verify_test_case_5),
15609
15610                 /** KASUMI encrypt only (UEA1) */
15611                 TEST_CASE_ST(ut_setup, ut_teardown,
15612                         test_kasumi_encryption_test_case_1),
15613                 TEST_CASE_ST(ut_setup, ut_teardown,
15614                         test_kasumi_encryption_test_case_1_sgl),
15615                 TEST_CASE_ST(ut_setup, ut_teardown,
15616                         test_kasumi_encryption_test_case_1_oop),
15617                 TEST_CASE_ST(ut_setup, ut_teardown,
15618                         test_kasumi_encryption_test_case_1_oop_sgl),
15619                 TEST_CASE_ST(ut_setup, ut_teardown,
15620                         test_kasumi_encryption_test_case_2),
15621                 TEST_CASE_ST(ut_setup, ut_teardown,
15622                         test_kasumi_encryption_test_case_3),
15623                 TEST_CASE_ST(ut_setup, ut_teardown,
15624                         test_kasumi_encryption_test_case_4),
15625                 TEST_CASE_ST(ut_setup, ut_teardown,
15626                         test_kasumi_encryption_test_case_5),
15627
15628                 /** KASUMI decrypt only (UEA1) */
15629                 TEST_CASE_ST(ut_setup, ut_teardown,
15630                         test_kasumi_decryption_test_case_1),
15631                 TEST_CASE_ST(ut_setup, ut_teardown,
15632                         test_kasumi_decryption_test_case_2),
15633                 TEST_CASE_ST(ut_setup, ut_teardown,
15634                         test_kasumi_decryption_test_case_3),
15635                 TEST_CASE_ST(ut_setup, ut_teardown,
15636                         test_kasumi_decryption_test_case_4),
15637                 TEST_CASE_ST(ut_setup, ut_teardown,
15638                         test_kasumi_decryption_test_case_5),
15639                 TEST_CASE_ST(ut_setup, ut_teardown,
15640                         test_kasumi_decryption_test_case_1_oop),
15641                 TEST_CASE_ST(ut_setup, ut_teardown,
15642                         test_kasumi_cipher_auth_test_case_1),
15643
15644                 /** KASUMI generate auth, then encrypt (F8) */
15645                 TEST_CASE_ST(ut_setup, ut_teardown,
15646                         test_kasumi_auth_cipher_test_case_1),
15647                 TEST_CASE_ST(ut_setup, ut_teardown,
15648                         test_kasumi_auth_cipher_test_case_2),
15649                 TEST_CASE_ST(ut_setup, ut_teardown,
15650                         test_kasumi_auth_cipher_test_case_2_oop),
15651                 TEST_CASE_ST(ut_setup, ut_teardown,
15652                         test_kasumi_auth_cipher_test_case_2_sgl),
15653                 TEST_CASE_ST(ut_setup, ut_teardown,
15654                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15655
15656                 /** KASUMI decrypt (F8), then verify auth */
15657                 TEST_CASE_ST(ut_setup, ut_teardown,
15658                         test_kasumi_auth_cipher_verify_test_case_1),
15659                 TEST_CASE_ST(ut_setup, ut_teardown,
15660                         test_kasumi_auth_cipher_verify_test_case_2),
15661                 TEST_CASE_ST(ut_setup, ut_teardown,
15662                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15663                 TEST_CASE_ST(ut_setup, ut_teardown,
15664                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15665                 TEST_CASE_ST(ut_setup, ut_teardown,
15666                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15667
15668                 TEST_CASES_END()
15669         }
15670 };
15671
15672 static struct unit_test_suite cryptodev_esn_testsuite  = {
15673         .suite_name = "ESN Test Suite",
15674         .setup = esn_testsuite_setup,
15675         .unit_test_cases = {
15676                 TEST_CASE_ST(ut_setup, ut_teardown,
15677                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
15678                 TEST_CASE_ST(ut_setup, ut_teardown,
15679                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
15680                 TEST_CASES_END()
15681         }
15682 };
15683
15684 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
15685         .suite_name = "Negative AES GCM Test Suite",
15686         .setup = negative_aes_gcm_testsuite_setup,
15687         .unit_test_cases = {
15688                 TEST_CASE_ST(ut_setup, ut_teardown,
15689                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
15690                 TEST_CASE_ST(ut_setup, ut_teardown,
15691                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
15692                 TEST_CASE_ST(ut_setup, ut_teardown,
15693                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
15694                 TEST_CASE_ST(ut_setup, ut_teardown,
15695                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
15696                 TEST_CASE_ST(ut_setup, ut_teardown,
15697                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
15698                 TEST_CASE_ST(ut_setup, ut_teardown,
15699                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
15700                 TEST_CASE_ST(ut_setup, ut_teardown,
15701                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
15702                 TEST_CASE_ST(ut_setup, ut_teardown,
15703                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
15704                 TEST_CASE_ST(ut_setup, ut_teardown,
15705                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
15706                 TEST_CASE_ST(ut_setup, ut_teardown,
15707                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
15708                 TEST_CASE_ST(ut_setup, ut_teardown,
15709                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
15710                 TEST_CASE_ST(ut_setup, ut_teardown,
15711                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
15712
15713                 TEST_CASES_END()
15714         }
15715 };
15716
15717 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
15718         .suite_name = "Negative AES GMAC Test Suite",
15719         .setup = negative_aes_gmac_testsuite_setup,
15720         .unit_test_cases = {
15721                 TEST_CASE_ST(ut_setup, ut_teardown,
15722                         authentication_verify_AES128_GMAC_fail_data_corrupt),
15723                 TEST_CASE_ST(ut_setup, ut_teardown,
15724                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
15725
15726                 TEST_CASES_END()
15727         }
15728 };
15729
15730 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
15731         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
15732         .setup = mixed_cipher_hash_testsuite_setup,
15733         .unit_test_cases = {
15734                 /** AUTH AES CMAC + CIPHER AES CTR */
15735                 TEST_CASE_ST(ut_setup, ut_teardown,
15736                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
15737                 TEST_CASE_ST(ut_setup, ut_teardown,
15738                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15739                 TEST_CASE_ST(ut_setup, ut_teardown,
15740                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15741                 TEST_CASE_ST(ut_setup, ut_teardown,
15742                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15743                 TEST_CASE_ST(ut_setup, ut_teardown,
15744                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
15745                 TEST_CASE_ST(ut_setup, ut_teardown,
15746                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
15747                 TEST_CASE_ST(ut_setup, ut_teardown,
15748                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
15749                 TEST_CASE_ST(ut_setup, ut_teardown,
15750                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
15751
15752                 /** AUTH ZUC + CIPHER SNOW3G */
15753                 TEST_CASE_ST(ut_setup, ut_teardown,
15754                         test_auth_zuc_cipher_snow_test_case_1),
15755                 TEST_CASE_ST(ut_setup, ut_teardown,
15756                         test_verify_auth_zuc_cipher_snow_test_case_1),
15757                 /** AUTH AES CMAC + CIPHER SNOW3G */
15758                 TEST_CASE_ST(ut_setup, ut_teardown,
15759                         test_auth_aes_cmac_cipher_snow_test_case_1),
15760                 TEST_CASE_ST(ut_setup, ut_teardown,
15761                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
15762                 /** AUTH ZUC + CIPHER AES CTR */
15763                 TEST_CASE_ST(ut_setup, ut_teardown,
15764                         test_auth_zuc_cipher_aes_ctr_test_case_1),
15765                 TEST_CASE_ST(ut_setup, ut_teardown,
15766                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
15767                 /** AUTH SNOW3G + CIPHER AES CTR */
15768                 TEST_CASE_ST(ut_setup, ut_teardown,
15769                         test_auth_snow_cipher_aes_ctr_test_case_1),
15770                 TEST_CASE_ST(ut_setup, ut_teardown,
15771                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
15772                 /** AUTH SNOW3G + CIPHER ZUC */
15773                 TEST_CASE_ST(ut_setup, ut_teardown,
15774                         test_auth_snow_cipher_zuc_test_case_1),
15775                 TEST_CASE_ST(ut_setup, ut_teardown,
15776                         test_verify_auth_snow_cipher_zuc_test_case_1),
15777                 /** AUTH AES CMAC + CIPHER ZUC */
15778                 TEST_CASE_ST(ut_setup, ut_teardown,
15779                         test_auth_aes_cmac_cipher_zuc_test_case_1),
15780                 TEST_CASE_ST(ut_setup, ut_teardown,
15781                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
15782
15783                 /** AUTH NULL + CIPHER SNOW3G */
15784                 TEST_CASE_ST(ut_setup, ut_teardown,
15785                         test_auth_null_cipher_snow_test_case_1),
15786                 TEST_CASE_ST(ut_setup, ut_teardown,
15787                         test_verify_auth_null_cipher_snow_test_case_1),
15788                 /** AUTH NULL + CIPHER ZUC */
15789                 TEST_CASE_ST(ut_setup, ut_teardown,
15790                         test_auth_null_cipher_zuc_test_case_1),
15791                 TEST_CASE_ST(ut_setup, ut_teardown,
15792                         test_verify_auth_null_cipher_zuc_test_case_1),
15793                 /** AUTH SNOW3G + CIPHER NULL */
15794                 TEST_CASE_ST(ut_setup, ut_teardown,
15795                         test_auth_snow_cipher_null_test_case_1),
15796                 TEST_CASE_ST(ut_setup, ut_teardown,
15797                         test_verify_auth_snow_cipher_null_test_case_1),
15798                 /** AUTH ZUC + CIPHER NULL */
15799                 TEST_CASE_ST(ut_setup, ut_teardown,
15800                         test_auth_zuc_cipher_null_test_case_1),
15801                 TEST_CASE_ST(ut_setup, ut_teardown,
15802                         test_verify_auth_zuc_cipher_null_test_case_1),
15803                 /** AUTH NULL + CIPHER AES CTR */
15804                 TEST_CASE_ST(ut_setup, ut_teardown,
15805                         test_auth_null_cipher_aes_ctr_test_case_1),
15806                 TEST_CASE_ST(ut_setup, ut_teardown,
15807                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
15808                 /** AUTH AES CMAC + CIPHER NULL */
15809                 TEST_CASE_ST(ut_setup, ut_teardown,
15810                         test_auth_aes_cmac_cipher_null_test_case_1),
15811                 TEST_CASE_ST(ut_setup, ut_teardown,
15812                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
15813                 TEST_CASES_END()
15814         }
15815 };
15816
15817 static int
15818 run_cryptodev_testsuite(const char *pmd_name)
15819 {
15820         uint8_t ret, j, i = 0, blk_start_idx = 0;
15821         const enum blockcipher_test_type blk_suites[] = {
15822                 BLKCIPHER_AES_CHAIN_TYPE,
15823                 BLKCIPHER_AES_CIPHERONLY_TYPE,
15824                 BLKCIPHER_AES_DOCSIS_TYPE,
15825                 BLKCIPHER_3DES_CHAIN_TYPE,
15826                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
15827                 BLKCIPHER_DES_CIPHERONLY_TYPE,
15828                 BLKCIPHER_DES_DOCSIS_TYPE,
15829                 BLKCIPHER_AUTHONLY_TYPE};
15830         struct unit_test_suite *static_suites[] = {
15831                 &cryptodev_multi_session_testsuite,
15832                 &cryptodev_null_testsuite,
15833                 &cryptodev_aes_ccm_auth_testsuite,
15834                 &cryptodev_aes_gcm_auth_testsuite,
15835                 &cryptodev_aes_gmac_auth_testsuite,
15836                 &cryptodev_snow3g_testsuite,
15837                 &cryptodev_chacha20_poly1305_testsuite,
15838                 &cryptodev_zuc_testsuite,
15839                 &cryptodev_hmac_md5_auth_testsuite,
15840                 &cryptodev_kasumi_testsuite,
15841                 &cryptodev_esn_testsuite,
15842                 &cryptodev_negative_aes_gcm_testsuite,
15843                 &cryptodev_negative_aes_gmac_testsuite,
15844                 &cryptodev_mixed_cipher_hash_testsuite,
15845                 &cryptodev_negative_hmac_sha1_testsuite,
15846                 &cryptodev_gen_testsuite,
15847 #ifdef RTE_LIB_SECURITY
15848                 &ipsec_proto_testsuite,
15849                 &pdcp_proto_testsuite,
15850                 &docsis_proto_testsuite,
15851 #endif
15852                 &end_testsuite
15853         };
15854         static struct unit_test_suite ts = {
15855                 .suite_name = "Cryptodev Unit Test Suite",
15856                 .setup = testsuite_setup,
15857                 .teardown = testsuite_teardown,
15858                 .unit_test_cases = {TEST_CASES_END()}
15859         };
15860
15861         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
15862
15863         if (gbl_driver_id == -1) {
15864                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
15865                 return TEST_SKIPPED;
15866         }
15867
15868         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
15869                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
15870
15871         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
15872         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
15873         ret = unit_test_suite_runner(&ts);
15874
15875         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
15876         free(ts.unit_test_suites);
15877         return ret;
15878 }
15879
15880 static int
15881 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
15882 {
15883         struct rte_cryptodev_info dev_info;
15884         uint8_t i, nb_devs;
15885         int driver_id;
15886
15887         driver_id = rte_cryptodev_driver_id_get(pmd_name);
15888         if (driver_id == -1) {
15889                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
15890                 return TEST_SKIPPED;
15891         }
15892
15893         nb_devs = rte_cryptodev_count();
15894         if (nb_devs < 1) {
15895                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
15896                 return TEST_SKIPPED;
15897         }
15898
15899         for (i = 0; i < nb_devs; i++) {
15900                 rte_cryptodev_info_get(i, &dev_info);
15901                 if (dev_info.driver_id == driver_id) {
15902                         if (!(dev_info.feature_flags & flag)) {
15903                                 RTE_LOG(INFO, USER1, "%s not supported\n",
15904                                                 flag_name);
15905                                 return TEST_SKIPPED;
15906                         }
15907                         return 0; /* found */
15908                 }
15909         }
15910
15911         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
15912         return TEST_SKIPPED;
15913 }
15914
15915 static int
15916 test_cryptodev_qat(void)
15917 {
15918         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
15919 }
15920
15921 static int
15922 test_cryptodev_virtio(void)
15923 {
15924         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
15925 }
15926
15927 static int
15928 test_cryptodev_aesni_mb(void)
15929 {
15930         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15931 }
15932
15933 static int
15934 test_cryptodev_cpu_aesni_mb(void)
15935 {
15936         int32_t rc;
15937         enum rte_security_session_action_type at = gbl_action_type;
15938         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15939         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
15940         gbl_action_type = at;
15941         return rc;
15942 }
15943
15944 static int
15945 test_cryptodev_chacha_poly_mb(void)
15946 {
15947         int32_t rc;
15948         enum rte_security_session_action_type at = gbl_action_type;
15949         rc = run_cryptodev_testsuite(
15950                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
15951         gbl_action_type = at;
15952         return rc;
15953 }
15954
15955 static int
15956 test_cryptodev_openssl(void)
15957 {
15958         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
15959 }
15960
15961 static int
15962 test_cryptodev_aesni_gcm(void)
15963 {
15964         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15965 }
15966
15967 static int
15968 test_cryptodev_cpu_aesni_gcm(void)
15969 {
15970         int32_t rc;
15971         enum rte_security_session_action_type at = gbl_action_type;
15972         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
15973         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
15974         gbl_action_type = at;
15975         return rc;
15976 }
15977
15978 static int
15979 test_cryptodev_mlx5(void)
15980 {
15981         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
15982 }
15983
15984 static int
15985 test_cryptodev_null(void)
15986 {
15987         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
15988 }
15989
15990 static int
15991 test_cryptodev_sw_snow3g(void)
15992 {
15993         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
15994 }
15995
15996 static int
15997 test_cryptodev_sw_kasumi(void)
15998 {
15999         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
16000 }
16001
16002 static int
16003 test_cryptodev_sw_zuc(void)
16004 {
16005         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
16006 }
16007
16008 static int
16009 test_cryptodev_armv8(void)
16010 {
16011         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
16012 }
16013
16014 static int
16015 test_cryptodev_mrvl(void)
16016 {
16017         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
16018 }
16019
16020 #ifdef RTE_CRYPTO_SCHEDULER
16021
16022 static int
16023 test_cryptodev_scheduler(void)
16024 {
16025         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
16026         const enum blockcipher_test_type blk_suites[] = {
16027                 BLKCIPHER_AES_CHAIN_TYPE,
16028                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16029                 BLKCIPHER_AUTHONLY_TYPE
16030         };
16031         static struct unit_test_suite scheduler_multicore = {
16032                 .suite_name = "Scheduler Multicore Unit Test Suite",
16033                 .setup = scheduler_multicore_testsuite_setup,
16034                 .teardown = scheduler_mode_testsuite_teardown,
16035                 .unit_test_cases = {TEST_CASES_END()}
16036         };
16037         static struct unit_test_suite scheduler_round_robin = {
16038                 .suite_name = "Scheduler Round Robin Unit Test Suite",
16039                 .setup = scheduler_roundrobin_testsuite_setup,
16040                 .teardown = scheduler_mode_testsuite_teardown,
16041                 .unit_test_cases = {TEST_CASES_END()}
16042         };
16043         static struct unit_test_suite scheduler_failover = {
16044                 .suite_name = "Scheduler Failover Unit Test Suite",
16045                 .setup = scheduler_failover_testsuite_setup,
16046                 .teardown = scheduler_mode_testsuite_teardown,
16047                 .unit_test_cases = {TEST_CASES_END()}
16048         };
16049         static struct unit_test_suite scheduler_pkt_size_distr = {
16050                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
16051                 .setup = scheduler_pkt_size_distr_testsuite_setup,
16052                 .teardown = scheduler_mode_testsuite_teardown,
16053                 .unit_test_cases = {TEST_CASES_END()}
16054         };
16055         struct unit_test_suite *sched_mode_suites[] = {
16056                 &scheduler_multicore,
16057                 &scheduler_round_robin,
16058                 &scheduler_failover,
16059                 &scheduler_pkt_size_distr
16060         };
16061         static struct unit_test_suite scheduler_config = {
16062                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
16063                 .unit_test_cases = {
16064                         TEST_CASE(test_scheduler_attach_worker_op),
16065                         TEST_CASE(test_scheduler_mode_multicore_op),
16066                         TEST_CASE(test_scheduler_mode_roundrobin_op),
16067                         TEST_CASE(test_scheduler_mode_failover_op),
16068                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
16069                         TEST_CASE(test_scheduler_detach_worker_op),
16070
16071                         TEST_CASES_END() /**< NULL terminate array */
16072                 }
16073         };
16074         struct unit_test_suite *static_suites[] = {
16075                 &scheduler_config,
16076                 &end_testsuite
16077         };
16078         static struct unit_test_suite ts = {
16079                 .suite_name = "Scheduler Unit Test Suite",
16080                 .setup = scheduler_testsuite_setup,
16081                 .teardown = testsuite_teardown,
16082                 .unit_test_cases = {TEST_CASES_END()}
16083         };
16084
16085         gbl_driver_id = rte_cryptodev_driver_id_get(
16086                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
16087
16088         if (gbl_driver_id == -1) {
16089                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
16090                 return TEST_SKIPPED;
16091         }
16092
16093         if (rte_cryptodev_driver_id_get(
16094                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
16095                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
16096                 return TEST_SKIPPED;
16097         }
16098
16099         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16100                 uint8_t blk_i = 0;
16101                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
16102                                 (struct unit_test_suite *) *
16103                                 (RTE_DIM(blk_suites) + 1));
16104                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
16105                                 blk_suites, RTE_DIM(blk_suites));
16106                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
16107         }
16108
16109         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16110                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
16111         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
16112                         RTE_DIM(sched_mode_suites));
16113         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16114         ret = unit_test_suite_runner(&ts);
16115
16116         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16117                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
16118                                 (*sched_mode_suites[sched_i]),
16119                                 RTE_DIM(blk_suites));
16120                 free(sched_mode_suites[sched_i]->unit_test_suites);
16121         }
16122         free(ts.unit_test_suites);
16123         return ret;
16124 }
16125
16126 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
16127
16128 #endif
16129
16130 static int
16131 test_cryptodev_dpaa2_sec(void)
16132 {
16133         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
16134 }
16135
16136 static int
16137 test_cryptodev_dpaa_sec(void)
16138 {
16139         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
16140 }
16141
16142 static int
16143 test_cryptodev_ccp(void)
16144 {
16145         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
16146 }
16147
16148 static int
16149 test_cryptodev_octeontx(void)
16150 {
16151         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
16152 }
16153
16154 static int
16155 test_cryptodev_caam_jr(void)
16156 {
16157         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
16158 }
16159
16160 static int
16161 test_cryptodev_nitrox(void)
16162 {
16163         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
16164 }
16165
16166 static int
16167 test_cryptodev_bcmfs(void)
16168 {
16169         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
16170 }
16171
16172 static int
16173 test_cryptodev_qat_raw_api(void)
16174 {
16175         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
16176         int ret;
16177
16178         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16179                         "RAW API");
16180         if (ret)
16181                 return ret;
16182
16183         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16184         ret = run_cryptodev_testsuite(pmd_name);
16185         global_api_test_type = CRYPTODEV_API_TEST;
16186
16187         return ret;
16188 }
16189
16190 static int
16191 test_cryptodev_cn9k(void)
16192 {
16193         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
16194 }
16195
16196 static int
16197 test_cryptodev_cn10k(void)
16198 {
16199         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
16200 }
16201
16202 static int
16203 test_cryptodev_dpaa2_sec_raw_api(void)
16204 {
16205         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16206         int ret;
16207
16208         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16209                         "RAW API");
16210         if (ret)
16211                 return ret;
16212
16213         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16214         ret = run_cryptodev_testsuite(pmd_name);
16215         global_api_test_type = CRYPTODEV_API_TEST;
16216
16217         return ret;
16218 }
16219
16220 static int
16221 test_cryptodev_dpaa_sec_raw_api(void)
16222 {
16223         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16224         int ret;
16225
16226         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16227                         "RAW API");
16228         if (ret)
16229                 return ret;
16230
16231         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16232         ret = run_cryptodev_testsuite(pmd_name);
16233         global_api_test_type = CRYPTODEV_API_TEST;
16234
16235         return ret;
16236 }
16237
16238 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
16239                 test_cryptodev_dpaa2_sec_raw_api);
16240 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
16241                 test_cryptodev_dpaa_sec_raw_api);
16242 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
16243                 test_cryptodev_qat_raw_api);
16244 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
16245 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
16246 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
16247         test_cryptodev_cpu_aesni_mb);
16248 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
16249         test_cryptodev_chacha_poly_mb);
16250 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16251 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16252 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16253         test_cryptodev_cpu_aesni_gcm);
16254 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16255 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16256 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16257 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16258 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16259 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16260 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16261 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16262 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16263 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16264 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16265 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16266 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16267 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16268 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16269 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16270 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
16271
16272 #endif /* !RTE_EXEC_ENV_WINDOWS */