app/test/test_cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020 Intel Corporation
   3  * Copyright 2020 NXP
   4  */
   5
   6 #ifndef RTE_EXEC_ENV_WINDOWS
   7
   8 #include <time.h>
   9
  10 #include <rte_common.h>
  11 #include <rte_hexdump.h>
  12 #include <rte_mbuf.h>
  13 #include <rte_malloc.h>
  14 #include <rte_memcpy.h>
  15 #include <rte_pause.h>
  16 #include <rte_bus_vdev.h>
  17 #include <rte_ether.h>
  18
  19 #include <rte_crypto.h>
  20 #include <rte_cryptodev.h>
  21 #include <rte_ip.h>
  22 #include <rte_string_fns.h>
  23 #include <rte_tcp.h>
  24 #include <rte_udp.h>
  25
  26 #ifdef RTE_CRYPTO_SCHEDULER
  27 #include <rte_cryptodev_scheduler.h>
  28 #include <rte_cryptodev_scheduler_operations.h>
  29 #endif
  30
  31 #include <rte_lcore.h>
  32
  33 #include "test.h"
  34 #include "test_cryptodev.h"
  35
  36 #include "test_cryptodev_blockcipher.h"
  37 #include "test_cryptodev_aes_test_vectors.h"
  38 #include "test_cryptodev_des_test_vectors.h"
  39 #include "test_cryptodev_hash_test_vectors.h"
  40 #include "test_cryptodev_kasumi_test_vectors.h"
  41 #include "test_cryptodev_kasumi_hash_test_vectors.h"
  42 #include "test_cryptodev_snow3g_test_vectors.h"
  43 #include "test_cryptodev_snow3g_hash_test_vectors.h"
  44 #include "test_cryptodev_zuc_test_vectors.h"
  45 #include "test_cryptodev_aead_test_vectors.h"
  46 #include "test_cryptodev_hmac_test_vectors.h"
  47 #include "test_cryptodev_mixed_test_vectors.h"
  48 #ifdef RTE_LIB_SECURITY
  49 #include "test_cryptodev_security_ipsec.h"
  50 #include "test_cryptodev_security_ipsec_test_vectors.h"
  51 #include "test_cryptodev_security_pdcp_test_vectors.h"
  52 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
  53 #include "test_cryptodev_security_pdcp_test_func.h"
  54 #include "test_cryptodev_security_docsis_test_vectors.h"
  55
  56 #define SDAP_DISABLED   0
  57 #define SDAP_ENABLED    1
  58 #endif
  59
  60 #define VDEV_ARGS_SIZE 100
  61 #define MAX_NB_SESSIONS 4
  62
  63 #define MAX_DRV_SERVICE_CTX_SIZE 256
  64
  65 #define MAX_RAW_DEQUEUE_COUNT   65535
  66
  67 #define IN_PLACE 0
  68 #define OUT_OF_PLACE 1
  69
  70 static int gbl_driver_id;
  71
  72 static enum rte_security_session_action_type gbl_action_type =
  73         RTE_SECURITY_ACTION_TYPE_NONE;
  74
  75 enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
  76
  77 struct crypto_unittest_params {
  78         struct rte_crypto_sym_xform cipher_xform;
  79         struct rte_crypto_sym_xform auth_xform;
  80         struct rte_crypto_sym_xform aead_xform;
  81 #ifdef RTE_LIB_SECURITY
  82         struct rte_security_docsis_xform docsis_xform;
  83 #endif
  84
  85         union {
  86                 struct rte_cryptodev_sym_session *sess;
  87 #ifdef RTE_LIB_SECURITY
  88                 struct rte_security_session *sec_session;
  89 #endif
  90         };
  91 #ifdef RTE_LIB_SECURITY
  92         enum rte_security_session_action_type type;
  93 #endif
  94         struct rte_crypto_op *op;
  95
  96         struct rte_mbuf *obuf, *ibuf;
  97
  98         uint8_t *digest;
  99 };
 100
 101 #define ALIGN_POW2_ROUNDUP(num, align) \
 102         (((num) + (align) - 1) & ~((align) - 1))
 103
 104 #define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts)  \
 105         for (j = 0; j < num_child_ts; index++, j++)                     \
 106                 parent_ts.unit_test_suites[index] = child_ts[j]
 107
 108 #define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types)   \
 109         for (j = 0; j < num_blk_types; index++, j++)                            \
 110                 parent_ts.unit_test_suites[index] =                             \
 111                                 build_blockcipher_test_suite(blk_types[j])
 112
 113 #define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types)             \
 114         for (j = index; j < index + num_blk_types; j++)                         \
 115                 free_blockcipher_test_suite(parent_ts.unit_test_suites[j])
 116
 117 /*
 118  * Forward declarations.
 119  */
 120 static int
 121 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
 122                 struct crypto_unittest_params *ut_params, uint8_t *cipher_key,
 123                 uint8_t *hmac_key);
 124
 125 static int
 126 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
 127                 struct crypto_unittest_params *ut_params,
 128                 struct crypto_testsuite_params *ts_param,
 129                 const uint8_t *cipher,
 130                 const uint8_t *digest,
 131                 const uint8_t *iv);
 132
 133 static int
 134 security_proto_supported(enum rte_security_session_action_type action,
 135         enum rte_security_session_protocol proto);
 136
 137 static int
 138 dev_configure_and_start(uint64_t ff_disable);
 139
 140 static struct rte_mbuf *
 141 setup_test_string(struct rte_mempool *mpool,
 142                 const char *string, size_t len, uint8_t blocksize)
 143 {
 144         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
 145         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
 146
 147         if (m) {
 148                 char *dst;
 149
 150                 memset(m->buf_addr, 0, m->buf_len);
 151                 dst = rte_pktmbuf_append(m, t_len);
 152                 if (!dst) {
 153                         rte_pktmbuf_free(m);
 154                         return NULL;
 155                 }
 156                 if (string != NULL)
 157                         rte_memcpy(dst, string, t_len);
 158                 else
 159                         memset(dst, 0, t_len);
 160         }
 161
 162         return m;
 163 }
 164
 165 /* Get number of bytes in X bits (rounding up) */
 166 static uint32_t
 167 ceil_byte_length(uint32_t num_bits)
 168 {
 169         if (num_bits % 8)
 170                 return ((num_bits >> 3) + 1);
 171         else
 172                 return (num_bits >> 3);
 173 }
 174
 175 static void
 176 post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
 177                 uint8_t is_op_success)
 178 {
 179         struct rte_crypto_op *op = user_data;
 180         op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS :
 181                         RTE_CRYPTO_OP_STATUS_ERROR;
 182 }
 183
 184 static struct crypto_testsuite_params testsuite_params = { NULL };
 185 struct crypto_testsuite_params *p_testsuite_params = &testsuite_params;
 186 static struct crypto_unittest_params unittest_params;
 187
 188 void
 189 process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 190                 struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth,
 191                 uint8_t len_in_bits, uint8_t cipher_iv_len)
 192 {
 193         struct rte_crypto_sym_op *sop = op->sym;
 194         struct rte_crypto_op *ret_op = NULL;
 195         struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX];
 196         struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv;
 197         union rte_crypto_sym_ofs ofs;
 198         struct rte_crypto_sym_vec vec;
 199         struct rte_crypto_sgl sgl, dest_sgl;
 200         uint32_t max_len;
 201         union rte_cryptodev_session_ctx sess;
 202         uint64_t auth_end_iova;
 203         uint32_t count = 0;
 204         struct rte_crypto_raw_dp_ctx *ctx;
 205         uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0,
 206                         auth_len = 0;
 207         int32_t n;
 208         uint32_t n_success;
 209         int ctx_service_size;
 210         int32_t status = 0;
 211         int enqueue_status, dequeue_status;
 212         struct crypto_unittest_params *ut_params = &unittest_params;
 213         int is_sgl = sop->m_src->nb_segs > 1;
 214         int is_oop = 0;
 215
 216         ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id);
 217         if (ctx_service_size < 0) {
 218                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 219                 return;
 220         }
 221
 222         ctx = malloc(ctx_service_size);
 223         if (!ctx) {
 224                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 225                 return;
 226         }
 227
 228         /* Both are enums, setting crypto_sess will suit any session type */
 229         sess.crypto_sess = op->sym->session;
 230
 231         if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx,
 232                         op->sess_type, sess, 0) < 0) {
 233                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 234                 goto exit;
 235         }
 236
 237         cipher_iv.iova = 0;
 238         cipher_iv.va = NULL;
 239         aad_auth_iv.iova = 0;
 240         aad_auth_iv.va = NULL;
 241         digest.iova = 0;
 242         digest.va = NULL;
 243         sgl.vec = data_vec;
 244         vec.num = 1;
 245         vec.src_sgl = &sgl;
 246         vec.iv = &cipher_iv;
 247         vec.digest = &digest;
 248         vec.aad = &aad_auth_iv;
 249         vec.status = &status;
 250
 251         ofs.raw = 0;
 252
 253         if ((sop->m_dst != NULL) && (sop->m_dst != sop->m_src))
 254                 is_oop = 1;
 255
 256         if (is_cipher && is_auth) {
 257                 cipher_offset = sop->cipher.data.offset;
 258                 cipher_len = sop->cipher.data.length;
 259                 auth_offset = sop->auth.data.offset;
 260                 auth_len = sop->auth.data.length;
 261                 max_len = RTE_MAX(cipher_offset + cipher_len,
 262                                 auth_offset + auth_len);
 263                 if (len_in_bits) {
 264                         max_len = max_len >> 3;
 265                         cipher_offset = cipher_offset >> 3;
 266                         auth_offset = auth_offset >> 3;
 267                         cipher_len = cipher_len >> 3;
 268                         auth_len = auth_len >> 3;
 269                 }
 270                 ofs.ofs.cipher.head = cipher_offset;
 271                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 272                 ofs.ofs.auth.head = auth_offset;
 273                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 274                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 275                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 276                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 277                                 op, void *, IV_OFFSET + cipher_iv_len);
 278                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 279                                 cipher_iv_len);
 280                 digest.va = (void *)sop->auth.digest.data;
 281                 digest.iova = sop->auth.digest.phys_addr;
 282
 283                 if (is_sgl) {
 284                         uint32_t remaining_off = auth_offset + auth_len;
 285                         struct rte_mbuf *sgl_buf = sop->m_src;
 286                         if (is_oop)
 287                                 sgl_buf = sop->m_dst;
 288
 289                         while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)
 290                                         && sgl_buf->next != NULL) {
 291                                 remaining_off -= rte_pktmbuf_data_len(sgl_buf);
 292                                 sgl_buf = sgl_buf->next;
 293                         }
 294
 295                         auth_end_iova = (uint64_t)rte_pktmbuf_iova_offset(
 296                                 sgl_buf, remaining_off);
 297                 } else {
 298                         auth_end_iova = rte_pktmbuf_iova(op->sym->m_src) +
 299                                                          auth_offset + auth_len;
 300                 }
 301                 /* Then check if digest-encrypted conditions are met */
 302                 if ((auth_offset + auth_len < cipher_offset + cipher_len) &&
 303                                 (digest.iova == auth_end_iova) && is_sgl)
 304                         max_len = RTE_MAX(max_len,
 305                                 auth_offset + auth_len +
 306                                 ut_params->auth_xform.auth.digest_length);
 307
 308         } else if (is_cipher) {
 309                 cipher_offset = sop->cipher.data.offset;
 310                 cipher_len = sop->cipher.data.length;
 311                 max_len = cipher_len + cipher_offset;
 312                 if (len_in_bits) {
 313                         max_len = max_len >> 3;
 314                         cipher_offset = cipher_offset >> 3;
 315                         cipher_len = cipher_len >> 3;
 316                 }
 317                 ofs.ofs.cipher.head = cipher_offset;
 318                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 319                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 320                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 321
 322         } else if (is_auth) {
 323                 auth_offset = sop->auth.data.offset;
 324                 auth_len = sop->auth.data.length;
 325                 max_len = auth_len + auth_offset;
 326                 if (len_in_bits) {
 327                         max_len = max_len >> 3;
 328                         auth_offset = auth_offset >> 3;
 329                         auth_len = auth_len >> 3;
 330                 }
 331                 ofs.ofs.auth.head = auth_offset;
 332                 ofs.ofs.auth.tail = max_len - auth_offset - auth_len;
 333                 aad_auth_iv.va = rte_crypto_op_ctod_offset(
 334                                 op, void *, IV_OFFSET + cipher_iv_len);
 335                 aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET +
 336                                 cipher_iv_len);
 337                 digest.va = (void *)sop->auth.digest.data;
 338                 digest.iova = sop->auth.digest.phys_addr;
 339
 340         } else { /* aead */
 341                 cipher_offset = sop->aead.data.offset;
 342                 cipher_len = sop->aead.data.length;
 343                 max_len = cipher_len + cipher_offset;
 344                 if (len_in_bits) {
 345                         max_len = max_len >> 3;
 346                         cipher_offset = cipher_offset >> 3;
 347                         cipher_len = cipher_len >> 3;
 348                 }
 349                 ofs.ofs.cipher.head = cipher_offset;
 350                 ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len;
 351                 cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 352                 cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET);
 353                 aad_auth_iv.va = (void *)sop->aead.aad.data;
 354                 aad_auth_iv.iova = sop->aead.aad.phys_addr;
 355                 digest.va = (void *)sop->aead.digest.data;
 356                 digest.iova = sop->aead.digest.phys_addr;
 357         }
 358
 359         n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len,
 360                         data_vec, RTE_DIM(data_vec));
 361         if (n < 0 || n > sop->m_src->nb_segs) {
 362                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 363                 goto exit;
 364         }
 365
 366         sgl.num = n;
 367         /* Out of place */
 368         if (is_oop) {
 369                 dest_sgl.vec = dest_data_vec;
 370                 vec.dest_sgl = &dest_sgl;
 371                 n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len,
 372                                 dest_data_vec, RTE_DIM(dest_data_vec));
 373                 if (n < 0 || n > sop->m_dst->nb_segs) {
 374                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 375                         goto exit;
 376                 }
 377                 dest_sgl.num = n;
 378         } else
 379                 vec.dest_sgl = NULL;
 380
 381         if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op,
 382                         &enqueue_status) < 1) {
 383                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 384                 goto exit;
 385         }
 386
 387         if (enqueue_status == 0) {
 388                 status = rte_cryptodev_raw_enqueue_done(ctx, 1);
 389                 if (status < 0) {
 390                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 391                         goto exit;
 392                 }
 393         } else if (enqueue_status < 0) {
 394                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 395                 goto exit;
 396         }
 397
 398         n = n_success = 0;
 399         while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
 400                 n = rte_cryptodev_raw_dequeue_burst(ctx,
 401                         NULL, 1, post_process_raw_dp_op,
 402                                 (void **)&ret_op, 0, &n_success,
 403                                 &dequeue_status);
 404                 if (dequeue_status < 0) {
 405                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 406                         goto exit;
 407                 }
 408                 if (n == 0)
 409                         rte_pause();
 410         }
 411
 412         if (n == 1 && dequeue_status == 0) {
 413                 if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
 414                         op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 415                         goto exit;
 416                 }
 417         }
 418
 419         op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
 420                         ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR ||
 421                         n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
 422                                         RTE_CRYPTO_OP_STATUS_SUCCESS;
 423
 424 exit:
 425         free(ctx);
 426 }
 427
 428 static void
 429 process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 430 {
 431         int32_t n, st;
 432         struct rte_crypto_sym_op *sop;
 433         union rte_crypto_sym_ofs ofs;
 434         struct rte_crypto_sgl sgl;
 435         struct rte_crypto_sym_vec symvec;
 436         struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr;
 437         struct rte_crypto_vec vec[UINT8_MAX];
 438
 439         sop = op->sym;
 440
 441         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->aead.data.offset,
 442                 sop->aead.data.length, vec, RTE_DIM(vec));
 443
 444         if (n < 0 || n != sop->m_src->nb_segs) {
 445                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 446                 return;
 447         }
 448
 449         sgl.vec = vec;
 450         sgl.num = n;
 451         symvec.src_sgl = &sgl;
 452         symvec.iv = &iv_ptr;
 453         symvec.digest = &digest_ptr;
 454         symvec.aad = &aad_ptr;
 455         symvec.status = &st;
 456         symvec.num = 1;
 457
 458         /* for CPU crypto the IOVA address is not required */
 459         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 460         digest_ptr.va = (void *)sop->aead.digest.data;
 461         aad_ptr.va = (void *)sop->aead.aad.data;
 462
 463         ofs.raw = 0;
 464
 465         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 466                 &symvec);
 467
 468         if (n != 1)
 469                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 470         else
 471                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 472 }
 473
 474 static void
 475 process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 476 {
 477         int32_t n, st;
 478         struct rte_crypto_sym_op *sop;
 479         union rte_crypto_sym_ofs ofs;
 480         struct rte_crypto_sgl sgl;
 481         struct rte_crypto_sym_vec symvec;
 482         struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr;
 483         struct rte_crypto_vec vec[UINT8_MAX];
 484
 485         sop = op->sym;
 486
 487         n = rte_crypto_mbuf_to_vec(sop->m_src, sop->auth.data.offset,
 488                 sop->auth.data.length, vec, RTE_DIM(vec));
 489
 490         if (n < 0 || n != sop->m_src->nb_segs) {
 491                 op->status = RTE_CRYPTO_OP_STATUS_ERROR;
 492                 return;
 493         }
 494
 495         sgl.vec = vec;
 496         sgl.num = n;
 497         symvec.src_sgl = &sgl;
 498         symvec.iv = &iv_ptr;
 499         symvec.digest = &digest_ptr;
 500         symvec.status = &st;
 501         symvec.num = 1;
 502
 503         iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET);
 504         digest_ptr.va = (void *)sop->auth.digest.data;
 505
 506         ofs.raw = 0;
 507         ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset;
 508         ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) -
 509                 (sop->cipher.data.offset + sop->cipher.data.length);
 510
 511         n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs,
 512                 &symvec);
 513
 514         if (n != 1)
 515                 op->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
 516         else
 517                 op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
 518 }
 519
 520 static struct rte_crypto_op *
 521 process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op)
 522 {
 523
 524         RTE_VERIFY(gbl_action_type != RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO);
 525
 526         if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
 527                 RTE_LOG(ERR, USER1, "Error sending packet for encryption\n");
 528                 return NULL;
 529         }
 530
 531         op = NULL;
 532
 533         while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
 534                 rte_pause();
 535
 536         if (op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
 537                 RTE_LOG(DEBUG, USER1, "Operation status %d\n", op->status);
 538                 return NULL;
 539         }
 540
 541         return op;
 542 }
 543
 544 static int
 545 testsuite_setup(void)
 546 {
 547         struct crypto_testsuite_params *ts_params = &testsuite_params;
 548         struct rte_cryptodev_info info;
 549         uint32_t i = 0, nb_devs, dev_id;
 550         uint16_t qp_id;
 551
 552         memset(ts_params, 0, sizeof(*ts_params));
 553
 554         ts_params->mbuf_pool = rte_mempool_lookup("CRYPTO_MBUFPOOL");
 555         if (ts_params->mbuf_pool == NULL) {
 556                 /* Not already created so create */
 557                 ts_params->mbuf_pool = rte_pktmbuf_pool_create(
 558                                 "CRYPTO_MBUFPOOL",
 559                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
 560                                 rte_socket_id());
 561                 if (ts_params->mbuf_pool == NULL) {
 562                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_MBUFPOOL\n");
 563                         return TEST_FAILED;
 564                 }
 565         }
 566
 567         ts_params->large_mbuf_pool = rte_mempool_lookup(
 568                         "CRYPTO_LARGE_MBUFPOOL");
 569         if (ts_params->large_mbuf_pool == NULL) {
 570                 /* Not already created so create */
 571                 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create(
 572                                 "CRYPTO_LARGE_MBUFPOOL",
 573                                 1, 0, 0, UINT16_MAX,
 574                                 rte_socket_id());
 575                 if (ts_params->large_mbuf_pool == NULL) {
 576                         RTE_LOG(ERR, USER1,
 577                                 "Can't create CRYPTO_LARGE_MBUFPOOL\n");
 578                         return TEST_FAILED;
 579                 }
 580         }
 581
 582         ts_params->op_mpool = rte_crypto_op_pool_create(
 583                         "MBUF_CRYPTO_SYM_OP_POOL",
 584                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
 585                         NUM_MBUFS, MBUF_CACHE_SIZE,
 586                         DEFAULT_NUM_XFORMS *
 587                         sizeof(struct rte_crypto_sym_xform) +
 588                         MAXIMUM_IV_LENGTH,
 589                         rte_socket_id());
 590         if (ts_params->op_mpool == NULL) {
 591                 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
 592                 return TEST_FAILED;
 593         }
 594
 595         nb_devs = rte_cryptodev_count();
 596         if (nb_devs < 1) {
 597                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
 598                 return TEST_SKIPPED;
 599         }
 600
 601         if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
 602                 RTE_LOG(WARNING, USER1, "No %s devices found?\n",
 603                                 rte_cryptodev_driver_name_get(gbl_driver_id));
 604                 return TEST_SKIPPED;
 605         }
 606
 607         /* Create list of valid crypto devs */
 608         for (i = 0; i < nb_devs; i++) {
 609                 rte_cryptodev_info_get(i, &info);
 610                 if (info.driver_id == gbl_driver_id)
 611                         ts_params->valid_devs[ts_params->valid_dev_count++] = i;
 612         }
 613
 614         if (ts_params->valid_dev_count < 1)
 615                 return TEST_FAILED;
 616
 617         /* Set up all the qps on the first of the valid devices found */
 618
 619         dev_id = ts_params->valid_devs[0];
 620
 621         rte_cryptodev_info_get(dev_id, &info);
 622
 623         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
 624         ts_params->conf.socket_id = SOCKET_ID_ANY;
 625         ts_params->conf.ff_disable = RTE_CRYPTODEV_FF_SECURITY;
 626
 627         unsigned int session_size =
 628                 rte_cryptodev_sym_get_private_session_size(dev_id);
 629
 630 #ifdef RTE_LIB_SECURITY
 631         unsigned int security_session_size = rte_security_session_get_size(
 632                         rte_cryptodev_get_sec_ctx(dev_id));
 633
 634         if (session_size < security_session_size)
 635                 session_size = security_session_size;
 636 #endif
 637         /*
 638          * Create mempool with maximum number of sessions.
 639          */
 640         if (info.sym.max_nb_sessions != 0 &&
 641                         info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
 642                 RTE_LOG(ERR, USER1, "Device does not support "
 643                                 "at least %u sessions\n",
 644                                 MAX_NB_SESSIONS);
 645                 return TEST_FAILED;
 646         }
 647
 648         ts_params->session_mpool = rte_cryptodev_sym_session_pool_create(
 649                         "test_sess_mp", MAX_NB_SESSIONS, 0, 0, 0,
 650                         SOCKET_ID_ANY);
 651         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
 652                         "session mempool allocation failed");
 653
 654         ts_params->session_priv_mpool = rte_mempool_create(
 655                         "test_sess_mp_priv",
 656                         MAX_NB_SESSIONS,
 657                         session_size,
 658                         0, 0, NULL, NULL, NULL,
 659                         NULL, SOCKET_ID_ANY,
 660                         0);
 661         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
 662                         "session mempool allocation failed");
 663
 664
 665
 666         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id,
 667                         &ts_params->conf),
 668                         "Failed to configure cryptodev %u with %u qps",
 669                         dev_id, ts_params->conf.nb_queue_pairs);
 670
 671         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
 672         ts_params->qp_conf.mp_session = ts_params->session_mpool;
 673         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
 674
 675         for (qp_id = 0; qp_id < info.max_nb_queue_pairs; qp_id++) {
 676                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
 677                         dev_id, qp_id, &ts_params->qp_conf,
 678                         rte_cryptodev_socket_id(dev_id)),
 679                         "Failed to setup queue pair %u on cryptodev %u",
 680                         qp_id, dev_id);
 681         }
 682
 683         return TEST_SUCCESS;
 684 }
 685
 686 static void
 687 testsuite_teardown(void)
 688 {
 689         struct crypto_testsuite_params *ts_params = &testsuite_params;
 690         int res;
 691
 692         if (ts_params->mbuf_pool != NULL) {
 693                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
 694                 rte_mempool_avail_count(ts_params->mbuf_pool));
 695         }
 696
 697         if (ts_params->op_mpool != NULL) {
 698                 RTE_LOG(DEBUG, USER1, "CRYPTO_OP_POOL count %u\n",
 699                 rte_mempool_avail_count(ts_params->op_mpool));
 700         }
 701
 702         /* Free session mempools */
 703         if (ts_params->session_priv_mpool != NULL) {
 704                 rte_mempool_free(ts_params->session_priv_mpool);
 705                 ts_params->session_priv_mpool = NULL;
 706         }
 707
 708         if (ts_params->session_mpool != NULL) {
 709                 rte_mempool_free(ts_params->session_mpool);
 710                 ts_params->session_mpool = NULL;
 711         }
 712
 713         res = rte_cryptodev_close(ts_params->valid_devs[0]);
 714         if (res)
 715                 RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
 716 }
 717
 718 static int
 719 check_capabilities_supported(enum rte_crypto_sym_xform_type type,
 720                 const int *algs, uint16_t num_algs)
 721 {
 722         uint8_t dev_id = testsuite_params.valid_devs[0];
 723         bool some_alg_supported = FALSE;
 724         uint16_t i;
 725
 726         for (i = 0; i < num_algs && !some_alg_supported; i++) {
 727                 struct rte_cryptodev_sym_capability_idx alg = {
 728                         type, {algs[i]}
 729                 };
 730                 if (rte_cryptodev_sym_capability_get(dev_id,
 731                                 &alg) != NULL)
 732                         some_alg_supported = TRUE;
 733         }
 734         if (!some_alg_supported)
 735                 return TEST_SKIPPED;
 736
 737         return 0;
 738 }
 739
 740 int
 741 check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
 742                 uint16_t num_ciphers)
 743 {
 744         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
 745                         (const int *) ciphers, num_ciphers);
 746 }
 747
 748 int
 749 check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
 750                 uint16_t num_auths)
 751 {
 752         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
 753                         (const int *) auths, num_auths);
 754 }
 755
 756 int
 757 check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
 758                 uint16_t num_aeads)
 759 {
 760         return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
 761                         (const int *) aeads, num_aeads);
 762 }
 763
 764 static int
 765 null_testsuite_setup(void)
 766 {
 767         struct crypto_testsuite_params *ts_params = &testsuite_params;
 768         uint8_t dev_id = ts_params->valid_devs[0];
 769         struct rte_cryptodev_info dev_info;
 770         const enum rte_crypto_cipher_algorithm ciphers[] = {
 771                 RTE_CRYPTO_CIPHER_NULL
 772         };
 773         const enum rte_crypto_auth_algorithm auths[] = {
 774                 RTE_CRYPTO_AUTH_NULL
 775         };
 776
 777         rte_cryptodev_info_get(dev_id, &dev_info);
 778
 779         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 780                 RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
 781                                 "testsuite not met\n");
 782                 return TEST_SKIPPED;
 783         }
 784
 785         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 786                         && check_auth_capabilities_supported(auths,
 787                         RTE_DIM(auths)) != 0) {
 788                 RTE_LOG(INFO, USER1, "Capability requirements for NULL "
 789                                 "testsuite not met\n");
 790                 return TEST_SKIPPED;
 791         }
 792
 793         return 0;
 794 }
 795
 796 static int
 797 crypto_gen_testsuite_setup(void)
 798 {
 799         struct crypto_testsuite_params *ts_params = &testsuite_params;
 800         uint8_t dev_id = ts_params->valid_devs[0];
 801         struct rte_cryptodev_info dev_info;
 802
 803         rte_cryptodev_info_get(dev_id, &dev_info);
 804
 805         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 806                 RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
 807                                 "testsuite not met\n");
 808                 return TEST_SKIPPED;
 809         }
 810
 811         return 0;
 812 }
 813
 814 #ifdef RTE_LIB_SECURITY
 815 static int
 816 ipsec_proto_testsuite_setup(void)
 817 {
 818         struct crypto_testsuite_params *ts_params = &testsuite_params;
 819         struct crypto_unittest_params *ut_params = &unittest_params;
 820         struct rte_cryptodev_info dev_info;
 821         int ret = 0;
 822
 823         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 824
 825         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) {
 826                 RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto "
 827                                 "testsuite not met\n");
 828                 return TEST_SKIPPED;
 829         }
 830
 831         /* Reconfigure to enable security */
 832         ret = dev_configure_and_start(0);
 833         if (ret != TEST_SUCCESS)
 834                 return ret;
 835
 836         /* Set action type */
 837         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
 838
 839         if (security_proto_supported(
 840                         RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL,
 841                         RTE_SECURITY_PROTOCOL_IPSEC) < 0) {
 842                 RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto "
 843                                 "test not met\n");
 844                 ret = TEST_SKIPPED;
 845         }
 846
 847         test_ipsec_alg_list_populate();
 848         test_ipsec_ah_alg_list_populate();
 849
 850         /*
 851          * Stop the device. Device would be started again by individual test
 852          * case setup routine.
 853          */
 854         rte_cryptodev_stop(ts_params->valid_devs[0]);
 855
 856         return ret;
 857 }
 858
 859 static int
 860 pdcp_proto_testsuite_setup(void)
 861 {
 862         struct crypto_testsuite_params *ts_params = &testsuite_params;
 863         uint8_t dev_id = ts_params->valid_devs[0];
 864         struct rte_cryptodev_info dev_info;
 865         const enum rte_crypto_cipher_algorithm ciphers[] = {
 866                 RTE_CRYPTO_CIPHER_NULL,
 867                 RTE_CRYPTO_CIPHER_AES_CTR,
 868                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
 869                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
 870         };
 871         const enum rte_crypto_auth_algorithm auths[] = {
 872                 RTE_CRYPTO_AUTH_NULL,
 873                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
 874                 RTE_CRYPTO_AUTH_AES_CMAC,
 875                 RTE_CRYPTO_AUTH_ZUC_EIA3
 876         };
 877
 878         rte_cryptodev_info_get(dev_id, &dev_info);
 879
 880         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 881                         !(dev_info.feature_flags &
 882                         RTE_CRYPTODEV_FF_SECURITY)) {
 883                 RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
 884                                 "testsuite not met\n");
 885                 return TEST_SKIPPED;
 886         }
 887
 888         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
 889                         && check_auth_capabilities_supported(auths,
 890                         RTE_DIM(auths)) != 0) {
 891                 RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
 892                                 "testsuite not met\n");
 893                 return TEST_SKIPPED;
 894         }
 895
 896         return 0;
 897 }
 898
 899 static int
 900 docsis_proto_testsuite_setup(void)
 901 {
 902         struct crypto_testsuite_params *ts_params = &testsuite_params;
 903         uint8_t dev_id = ts_params->valid_devs[0];
 904         struct rte_cryptodev_info dev_info;
 905         const enum rte_crypto_cipher_algorithm ciphers[] = {
 906                 RTE_CRYPTO_CIPHER_AES_DOCSISBPI
 907         };
 908
 909         rte_cryptodev_info_get(dev_id, &dev_info);
 910
 911         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 912                         !(dev_info.feature_flags &
 913                         RTE_CRYPTODEV_FF_SECURITY)) {
 914                 RTE_LOG(INFO, USER1, "Feature flag requirements for DOCSIS "
 915                                 "Proto testsuite not met\n");
 916                 return TEST_SKIPPED;
 917         }
 918
 919         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
 920                 RTE_LOG(INFO, USER1, "Capability requirements for DOCSIS Proto "
 921                                 "testsuite not met\n");
 922                 return TEST_SKIPPED;
 923         }
 924
 925         return 0;
 926 }
 927 #endif
 928
 929 static int
 930 aes_ccm_auth_testsuite_setup(void)
 931 {
 932         struct crypto_testsuite_params *ts_params = &testsuite_params;
 933         uint8_t dev_id = ts_params->valid_devs[0];
 934         struct rte_cryptodev_info dev_info;
 935         const enum rte_crypto_aead_algorithm aeads[] = {
 936                 RTE_CRYPTO_AEAD_AES_CCM
 937         };
 938
 939         rte_cryptodev_info_get(dev_id, &dev_info);
 940
 941         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 942                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 943                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
 944                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
 945                                 "testsuite not met\n");
 946                 return TEST_SKIPPED;
 947         }
 948
 949         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 950                 RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
 951                                 "testsuite not met\n");
 952                 return TEST_SKIPPED;
 953         }
 954
 955         return 0;
 956 }
 957
 958 static int
 959 aes_gcm_auth_testsuite_setup(void)
 960 {
 961         struct crypto_testsuite_params *ts_params = &testsuite_params;
 962         uint8_t dev_id = ts_params->valid_devs[0];
 963         struct rte_cryptodev_info dev_info;
 964         const enum rte_crypto_aead_algorithm aeads[] = {
 965                 RTE_CRYPTO_AEAD_AES_GCM
 966         };
 967
 968         rte_cryptodev_info_get(dev_id, &dev_info);
 969
 970         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
 971                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
 972                                 "testsuite not met\n");
 973                 return TEST_SKIPPED;
 974         }
 975
 976         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
 977                 RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
 978                                 "testsuite not met\n");
 979                 return TEST_SKIPPED;
 980         }
 981
 982         return 0;
 983 }
 984
 985 static int
 986 aes_gmac_auth_testsuite_setup(void)
 987 {
 988         struct crypto_testsuite_params *ts_params = &testsuite_params;
 989         uint8_t dev_id = ts_params->valid_devs[0];
 990         struct rte_cryptodev_info dev_info;
 991         const enum rte_crypto_auth_algorithm auths[] = {
 992                 RTE_CRYPTO_AUTH_AES_GMAC
 993         };
 994
 995         rte_cryptodev_info_get(dev_id, &dev_info);
 996
 997         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
 998                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
 999                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1000                 RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
1001                                 "testsuite not met\n");
1002                 return TEST_SKIPPED;
1003         }
1004
1005         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1006                 RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
1007                                 "testsuite not met\n");
1008                 return TEST_SKIPPED;
1009         }
1010
1011         return 0;
1012 }
1013
1014 static int
1015 chacha20_poly1305_testsuite_setup(void)
1016 {
1017         struct crypto_testsuite_params *ts_params = &testsuite_params;
1018         uint8_t dev_id = ts_params->valid_devs[0];
1019         struct rte_cryptodev_info dev_info;
1020         const enum rte_crypto_aead_algorithm aeads[] = {
1021                 RTE_CRYPTO_AEAD_CHACHA20_POLY1305
1022         };
1023
1024         rte_cryptodev_info_get(dev_id, &dev_info);
1025
1026         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1027                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1028                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1029                 RTE_LOG(INFO, USER1, "Feature flag requirements for "
1030                                 "Chacha20-Poly1305 testsuite not met\n");
1031                 return TEST_SKIPPED;
1032         }
1033
1034         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1035                 RTE_LOG(INFO, USER1, "Capability requirements for "
1036                                 "Chacha20-Poly1305 testsuite not met\n");
1037                 return TEST_SKIPPED;
1038         }
1039
1040         return 0;
1041 }
1042
1043 static int
1044 snow3g_testsuite_setup(void)
1045 {
1046         struct crypto_testsuite_params *ts_params = &testsuite_params;
1047         uint8_t dev_id = ts_params->valid_devs[0];
1048         struct rte_cryptodev_info dev_info;
1049         const enum rte_crypto_cipher_algorithm ciphers[] = {
1050                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1051
1052         };
1053         const enum rte_crypto_auth_algorithm auths[] = {
1054                 RTE_CRYPTO_AUTH_SNOW3G_UIA2
1055         };
1056
1057         rte_cryptodev_info_get(dev_id, &dev_info);
1058
1059         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1060                 RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
1061                                 "testsuite not met\n");
1062                 return TEST_SKIPPED;
1063         }
1064
1065         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1066                         && check_auth_capabilities_supported(auths,
1067                         RTE_DIM(auths)) != 0) {
1068                 RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
1069                                 "testsuite not met\n");
1070                 return TEST_SKIPPED;
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int
1077 zuc_testsuite_setup(void)
1078 {
1079         struct crypto_testsuite_params *ts_params = &testsuite_params;
1080         uint8_t dev_id = ts_params->valid_devs[0];
1081         struct rte_cryptodev_info dev_info;
1082         const enum rte_crypto_cipher_algorithm ciphers[] = {
1083                 RTE_CRYPTO_CIPHER_ZUC_EEA3
1084         };
1085         const enum rte_crypto_auth_algorithm auths[] = {
1086                 RTE_CRYPTO_AUTH_ZUC_EIA3
1087         };
1088
1089         rte_cryptodev_info_get(dev_id, &dev_info);
1090
1091         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1092                 RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
1093                                 "testsuite not met\n");
1094                 return TEST_SKIPPED;
1095         }
1096
1097         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1098                         && check_auth_capabilities_supported(auths,
1099                         RTE_DIM(auths)) != 0) {
1100                 RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
1101                                 "testsuite not met\n");
1102                 return TEST_SKIPPED;
1103         }
1104
1105         return 0;
1106 }
1107
1108 static int
1109 hmac_md5_auth_testsuite_setup(void)
1110 {
1111         struct crypto_testsuite_params *ts_params = &testsuite_params;
1112         uint8_t dev_id = ts_params->valid_devs[0];
1113         struct rte_cryptodev_info dev_info;
1114         const enum rte_crypto_auth_algorithm auths[] = {
1115                 RTE_CRYPTO_AUTH_MD5_HMAC
1116         };
1117
1118         rte_cryptodev_info_get(dev_id, &dev_info);
1119
1120         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1121                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1122                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1123                 RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
1124                                 "Auth testsuite not met\n");
1125                 return TEST_SKIPPED;
1126         }
1127
1128         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1129                 RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
1130                                 "testsuite not met\n");
1131                 return TEST_SKIPPED;
1132         }
1133
1134         return 0;
1135 }
1136
1137 static int
1138 kasumi_testsuite_setup(void)
1139 {
1140         struct crypto_testsuite_params *ts_params = &testsuite_params;
1141         uint8_t dev_id = ts_params->valid_devs[0];
1142         struct rte_cryptodev_info dev_info;
1143         const enum rte_crypto_cipher_algorithm ciphers[] = {
1144                 RTE_CRYPTO_CIPHER_KASUMI_F8
1145         };
1146         const enum rte_crypto_auth_algorithm auths[] = {
1147                 RTE_CRYPTO_AUTH_KASUMI_F9
1148         };
1149
1150         rte_cryptodev_info_get(dev_id, &dev_info);
1151
1152         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1153                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1154                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1155                 RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
1156                                 "testsuite not met\n");
1157                 return TEST_SKIPPED;
1158         }
1159
1160         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1161                         && check_auth_capabilities_supported(auths,
1162                         RTE_DIM(auths)) != 0) {
1163                 RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
1164                                 "testsuite not met\n");
1165                 return TEST_SKIPPED;
1166         }
1167
1168         return 0;
1169 }
1170
1171 static int
1172 negative_aes_gcm_testsuite_setup(void)
1173 {
1174         struct crypto_testsuite_params *ts_params = &testsuite_params;
1175         uint8_t dev_id = ts_params->valid_devs[0];
1176         struct rte_cryptodev_info dev_info;
1177         const enum rte_crypto_aead_algorithm aeads[] = {
1178                 RTE_CRYPTO_AEAD_AES_GCM
1179         };
1180
1181         rte_cryptodev_info_get(dev_id, &dev_info);
1182
1183         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1184                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1185                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1186                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1187                                 "AES GCM testsuite not met\n");
1188                 return TEST_SKIPPED;
1189         }
1190
1191         if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
1192                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1193                                 "AES GCM testsuite not met\n");
1194                 return TEST_SKIPPED;
1195         }
1196
1197         return 0;
1198 }
1199
1200 static int
1201 negative_aes_gmac_testsuite_setup(void)
1202 {
1203         struct crypto_testsuite_params *ts_params = &testsuite_params;
1204         uint8_t dev_id = ts_params->valid_devs[0];
1205         struct rte_cryptodev_info dev_info;
1206         const enum rte_crypto_auth_algorithm auths[] = {
1207                 RTE_CRYPTO_AUTH_AES_GMAC
1208         };
1209
1210         rte_cryptodev_info_get(dev_id, &dev_info);
1211
1212         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1213                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1214                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1215                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1216                                 "AES GMAC testsuite not met\n");
1217                 return TEST_SKIPPED;
1218         }
1219
1220         if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
1221                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1222                                 "AES GMAC testsuite not met\n");
1223                 return TEST_SKIPPED;
1224         }
1225
1226         return 0;
1227 }
1228
1229 static int
1230 mixed_cipher_hash_testsuite_setup(void)
1231 {
1232         struct crypto_testsuite_params *ts_params = &testsuite_params;
1233         uint8_t dev_id = ts_params->valid_devs[0];
1234         struct rte_cryptodev_info dev_info;
1235         uint64_t feat_flags;
1236         const enum rte_crypto_cipher_algorithm ciphers[] = {
1237                 RTE_CRYPTO_CIPHER_NULL,
1238                 RTE_CRYPTO_CIPHER_AES_CTR,
1239                 RTE_CRYPTO_CIPHER_ZUC_EEA3,
1240                 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
1241         };
1242         const enum rte_crypto_auth_algorithm auths[] = {
1243                 RTE_CRYPTO_AUTH_NULL,
1244                 RTE_CRYPTO_AUTH_SNOW3G_UIA2,
1245                 RTE_CRYPTO_AUTH_AES_CMAC,
1246                 RTE_CRYPTO_AUTH_ZUC_EIA3
1247         };
1248
1249         rte_cryptodev_info_get(dev_id, &dev_info);
1250         feat_flags = dev_info.feature_flags;
1251
1252         if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1253                         (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
1254                 RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
1255                                 "Cipher Hash testsuite not met\n");
1256                 return TEST_SKIPPED;
1257         }
1258
1259         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1260                         && check_auth_capabilities_supported(auths,
1261                         RTE_DIM(auths)) != 0) {
1262                 RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
1263                                 "Cipher Hash testsuite not met\n");
1264                 return TEST_SKIPPED;
1265         }
1266
1267         return 0;
1268 }
1269
1270 static int
1271 esn_testsuite_setup(void)
1272 {
1273         struct crypto_testsuite_params *ts_params = &testsuite_params;
1274         uint8_t dev_id = ts_params->valid_devs[0];
1275         struct rte_cryptodev_info dev_info;
1276         const enum rte_crypto_cipher_algorithm ciphers[] = {
1277                 RTE_CRYPTO_CIPHER_AES_CBC
1278         };
1279         const enum rte_crypto_auth_algorithm auths[] = {
1280                 RTE_CRYPTO_AUTH_SHA1_HMAC
1281         };
1282
1283         rte_cryptodev_info_get(dev_id, &dev_info);
1284
1285         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1286                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1287                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1288                 RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
1289                                 "testsuite not met\n");
1290                 return TEST_SKIPPED;
1291         }
1292
1293         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1294                         && check_auth_capabilities_supported(auths,
1295                         RTE_DIM(auths)) != 0) {
1296                 RTE_LOG(INFO, USER1, "Capability requirements for ESN "
1297                                 "testsuite not met\n");
1298                 return TEST_SKIPPED;
1299         }
1300
1301         return 0;
1302 }
1303
1304 static int
1305 multi_session_testsuite_setup(void)
1306 {
1307         struct crypto_testsuite_params *ts_params = &testsuite_params;
1308         uint8_t dev_id = ts_params->valid_devs[0];
1309         struct rte_cryptodev_info dev_info;
1310         const enum rte_crypto_cipher_algorithm ciphers[] = {
1311                 RTE_CRYPTO_CIPHER_AES_CBC
1312         };
1313         const enum rte_crypto_auth_algorithm auths[] = {
1314                 RTE_CRYPTO_AUTH_SHA512_HMAC
1315         };
1316
1317         rte_cryptodev_info_get(dev_id, &dev_info);
1318
1319         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
1320                 RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
1321                                 "Session testsuite not met\n");
1322                 return TEST_SKIPPED;
1323         }
1324
1325         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1326                         && check_auth_capabilities_supported(auths,
1327                         RTE_DIM(auths)) != 0) {
1328                 RTE_LOG(INFO, USER1, "Capability requirements for Multi "
1329                                 "Session testsuite not met\n");
1330                 return TEST_SKIPPED;
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int
1337 negative_hmac_sha1_testsuite_setup(void)
1338 {
1339         struct crypto_testsuite_params *ts_params = &testsuite_params;
1340         uint8_t dev_id = ts_params->valid_devs[0];
1341         struct rte_cryptodev_info dev_info;
1342         const enum rte_crypto_cipher_algorithm ciphers[] = {
1343                 RTE_CRYPTO_CIPHER_AES_CBC
1344         };
1345         const enum rte_crypto_auth_algorithm auths[] = {
1346                 RTE_CRYPTO_AUTH_SHA1_HMAC
1347         };
1348
1349         rte_cryptodev_info_get(dev_id, &dev_info);
1350
1351         if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
1352                         ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
1353                         !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
1354                 RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
1355                                 "HMAC SHA1 testsuite not met\n");
1356                 return TEST_SKIPPED;
1357         }
1358
1359         if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
1360                         && check_auth_capabilities_supported(auths,
1361                         RTE_DIM(auths)) != 0) {
1362                 RTE_LOG(INFO, USER1, "Capability requirements for Negative "
1363                                 "HMAC SHA1 testsuite not met\n");
1364                 return TEST_SKIPPED;
1365         }
1366
1367         return 0;
1368 }
1369
1370 static int
1371 dev_configure_and_start(uint64_t ff_disable)
1372 {
1373         struct crypto_testsuite_params *ts_params = &testsuite_params;
1374         struct crypto_unittest_params *ut_params = &unittest_params;
1375
1376         uint16_t qp_id;
1377
1378         /* Clear unit test parameters before running test */
1379         memset(ut_params, 0, sizeof(*ut_params));
1380
1381         /* Reconfigure device to default parameters */
1382         ts_params->conf.socket_id = SOCKET_ID_ANY;
1383         ts_params->conf.ff_disable = ff_disable;
1384         ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
1385         ts_params->qp_conf.mp_session = ts_params->session_mpool;
1386         ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
1387
1388         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1389                         &ts_params->conf),
1390                         "Failed to configure cryptodev %u",
1391                         ts_params->valid_devs[0]);
1392
1393         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
1394                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1395                         ts_params->valid_devs[0], qp_id,
1396                         &ts_params->qp_conf,
1397                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1398                         "Failed to setup queue pair %u on cryptodev %u",
1399                         qp_id, ts_params->valid_devs[0]);
1400         }
1401
1402
1403         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
1404
1405         /* Start the device */
1406         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
1407                         "Failed to start cryptodev %u",
1408                         ts_params->valid_devs[0]);
1409
1410         return TEST_SUCCESS;
1411 }
1412
1413 int
1414 ut_setup(void)
1415 {
1416         /* Configure and start the device with security feature disabled */
1417         return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
1418 }
1419
1420 static int
1421 ut_setup_security(void)
1422 {
1423         /* Configure and start the device with no features disabled */
1424         return dev_configure_and_start(0);
1425 }
1426
1427 void
1428 ut_teardown(void)
1429 {
1430         struct crypto_testsuite_params *ts_params = &testsuite_params;
1431         struct crypto_unittest_params *ut_params = &unittest_params;
1432
1433         /* free crypto session structure */
1434 #ifdef RTE_LIB_SECURITY
1435         if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
1436                 if (ut_params->sec_session) {
1437                         rte_security_session_destroy(rte_cryptodev_get_sec_ctx
1438                                                 (ts_params->valid_devs[0]),
1439                                                 ut_params->sec_session);
1440                         ut_params->sec_session = NULL;
1441                 }
1442         } else
1443 #endif
1444         {
1445                 if (ut_params->sess) {
1446                         rte_cryptodev_sym_session_clear(
1447                                         ts_params->valid_devs[0],
1448                                         ut_params->sess);
1449                         rte_cryptodev_sym_session_free(ut_params->sess);
1450                         ut_params->sess = NULL;
1451                 }
1452         }
1453
1454         /* free crypto operation structure */
1455         if (ut_params->op)
1456                 rte_crypto_op_free(ut_params->op);
1457
1458         /*
1459          * free mbuf - both obuf and ibuf are usually the same,
1460          * so check if they point at the same address is necessary,
1461          * to avoid freeing the mbuf twice.
1462          */
1463         if (ut_params->obuf) {
1464                 rte_pktmbuf_free(ut_params->obuf);
1465                 if (ut_params->ibuf == ut_params->obuf)
1466                         ut_params->ibuf = 0;
1467                 ut_params->obuf = 0;
1468         }
1469         if (ut_params->ibuf) {
1470                 rte_pktmbuf_free(ut_params->ibuf);
1471                 ut_params->ibuf = 0;
1472         }
1473
1474         if (ts_params->mbuf_pool != NULL)
1475                 RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
1476                         rte_mempool_avail_count(ts_params->mbuf_pool));
1477
1478         /* Stop the device */
1479         rte_cryptodev_stop(ts_params->valid_devs[0]);
1480 }
1481
1482 static int
1483 test_device_configure_invalid_dev_id(void)
1484 {
1485         struct crypto_testsuite_params *ts_params = &testsuite_params;
1486         uint16_t dev_id, num_devs = 0;
1487
1488         TEST_ASSERT((num_devs = rte_cryptodev_count()) >= 1,
1489                         "Need at least %d devices for test", 1);
1490
1491         /* valid dev_id values */
1492         dev_id = ts_params->valid_devs[0];
1493
1494         /* Stop the device in case it's started so it can be configured */
1495         rte_cryptodev_stop(dev_id);
1496
1497         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(dev_id, &ts_params->conf),
1498                         "Failed test for rte_cryptodev_configure: "
1499                         "invalid dev_num %u", dev_id);
1500
1501         /* invalid dev_id values */
1502         dev_id = num_devs;
1503
1504         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1505                         "Failed test for rte_cryptodev_configure: "
1506                         "invalid dev_num %u", dev_id);
1507
1508         dev_id = 0xff;
1509
1510         TEST_ASSERT_FAIL(rte_cryptodev_configure(dev_id, &ts_params->conf),
1511                         "Failed test for rte_cryptodev_configure:"
1512                         "invalid dev_num %u", dev_id);
1513
1514         return TEST_SUCCESS;
1515 }
1516
1517 static int
1518 test_device_configure_invalid_queue_pair_ids(void)
1519 {
1520         struct crypto_testsuite_params *ts_params = &testsuite_params;
1521         uint16_t orig_nb_qps = ts_params->conf.nb_queue_pairs;
1522
1523         /* Stop the device in case it's started so it can be configured */
1524         rte_cryptodev_stop(ts_params->valid_devs[0]);
1525
1526         /* valid - max value queue pairs */
1527         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1528
1529         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1530                         &ts_params->conf),
1531                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1532                         ts_params->valid_devs[0], ts_params->conf.nb_queue_pairs);
1533
1534         /* valid - one queue pairs */
1535         ts_params->conf.nb_queue_pairs = 1;
1536
1537         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1538                         &ts_params->conf),
1539                         "Failed to configure cryptodev: dev_id %u, qp_id %u",
1540                         ts_params->valid_devs[0],
1541                         ts_params->conf.nb_queue_pairs);
1542
1543
1544         /* invalid - zero queue pairs */
1545         ts_params->conf.nb_queue_pairs = 0;
1546
1547         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1548                         &ts_params->conf),
1549                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1550                         " invalid qps: %u",
1551                         ts_params->valid_devs[0],
1552                         ts_params->conf.nb_queue_pairs);
1553
1554
1555         /* invalid - max value supported by field queue pairs */
1556         ts_params->conf.nb_queue_pairs = UINT16_MAX;
1557
1558         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1559                         &ts_params->conf),
1560                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1561                         " invalid qps: %u",
1562                         ts_params->valid_devs[0],
1563                         ts_params->conf.nb_queue_pairs);
1564
1565
1566         /* invalid - max value + 1 queue pairs */
1567         ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
1568
1569         TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
1570                         &ts_params->conf),
1571                         "Failed test for rte_cryptodev_configure, dev_id %u,"
1572                         " invalid qps: %u",
1573                         ts_params->valid_devs[0],
1574                         ts_params->conf.nb_queue_pairs);
1575
1576         /* revert to original testsuite value */
1577         ts_params->conf.nb_queue_pairs = orig_nb_qps;
1578
1579         return TEST_SUCCESS;
1580 }
1581
1582 static int
1583 test_queue_pair_descriptor_setup(void)
1584 {
1585         struct crypto_testsuite_params *ts_params = &testsuite_params;
1586         struct rte_cryptodev_qp_conf qp_conf = {
1587                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
1588         };
1589         uint16_t qp_id;
1590
1591         /* Stop the device in case it's started so it can be configured */
1592         rte_cryptodev_stop(ts_params->valid_devs[0]);
1593
1594         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
1595                         &ts_params->conf),
1596                         "Failed to configure cryptodev %u",
1597                         ts_params->valid_devs[0]);
1598
1599         /*
1600          * Test various ring sizes on this device. memzones can't be
1601          * freed so are re-used if ring is released and re-created.
1602          */
1603         qp_conf.nb_descriptors = MIN_NUM_OPS_INFLIGHT; /* min size*/
1604         qp_conf.mp_session = ts_params->session_mpool;
1605         qp_conf.mp_session_private = ts_params->session_priv_mpool;
1606
1607         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1608                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1609                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1610                                 rte_cryptodev_socket_id(
1611                                                 ts_params->valid_devs[0])),
1612                                 "Failed test for "
1613                                 "rte_cryptodev_queue_pair_setup: num_inflights "
1614                                 "%u on qp %u on cryptodev %u",
1615                                 qp_conf.nb_descriptors, qp_id,
1616                                 ts_params->valid_devs[0]);
1617         }
1618
1619         qp_conf.nb_descriptors = (uint32_t)(MAX_NUM_OPS_INFLIGHT / 2);
1620
1621         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1622                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1623                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1624                                 rte_cryptodev_socket_id(
1625                                                 ts_params->valid_devs[0])),
1626                                 "Failed test for"
1627                                 " rte_cryptodev_queue_pair_setup: num_inflights"
1628                                 " %u on qp %u on cryptodev %u",
1629                                 qp_conf.nb_descriptors, qp_id,
1630                                 ts_params->valid_devs[0]);
1631         }
1632
1633         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT; /* valid */
1634
1635         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1636                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1637                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1638                                 rte_cryptodev_socket_id(
1639                                                 ts_params->valid_devs[0])),
1640                                 "Failed test for "
1641                                 "rte_cryptodev_queue_pair_setup: num_inflights"
1642                                 " %u on qp %u on cryptodev %u",
1643                                 qp_conf.nb_descriptors, qp_id,
1644                                 ts_params->valid_devs[0]);
1645         }
1646
1647         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;
1648
1649         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs; qp_id++) {
1650                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
1651                                 ts_params->valid_devs[0], qp_id, &qp_conf,
1652                                 rte_cryptodev_socket_id(
1653                                                 ts_params->valid_devs[0])),
1654                                 "Failed test for"
1655                                 " rte_cryptodev_queue_pair_setup:"
1656                                 "num_inflights %u on qp %u on cryptodev %u",
1657                                 qp_conf.nb_descriptors, qp_id,
1658                                 ts_params->valid_devs[0]);
1659         }
1660
1661         /* test invalid queue pair id */
1662         qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;      /*valid */
1663
1664         qp_id = ts_params->conf.nb_queue_pairs;         /*invalid */
1665
1666         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1667                         ts_params->valid_devs[0],
1668                         qp_id, &qp_conf,
1669                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1670                         "Failed test for rte_cryptodev_queue_pair_setup:"
1671                         "invalid qp %u on cryptodev %u",
1672                         qp_id, ts_params->valid_devs[0]);
1673
1674         qp_id = 0xffff; /*invalid*/
1675
1676         TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
1677                         ts_params->valid_devs[0],
1678                         qp_id, &qp_conf,
1679                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
1680                         "Failed test for rte_cryptodev_queue_pair_setup:"
1681                         "invalid qp %u on cryptodev %u",
1682                         qp_id, ts_params->valid_devs[0]);
1683
1684         return TEST_SUCCESS;
1685 }
1686
1687 /* ***** Plaintext data for tests ***** */
1688
1689 const char catch_22_quote_1[] =
1690                 "There was only one catch and that was Catch-22, which "
1691                 "specified that a concern for one's safety in the face of "
1692                 "dangers that were real and immediate was the process of a "
1693                 "rational mind. Orr was crazy and could be grounded. All he "
1694                 "had to do was ask; and as soon as he did, he would no longer "
1695                 "be crazy and would have to fly more missions. Orr would be "
1696                 "crazy to fly more missions and sane if he didn't, but if he "
1697                 "was sane he had to fly them. If he flew them he was crazy "
1698                 "and didn't have to; but if he didn't want to he was sane and "
1699                 "had to. Yossarian was moved very deeply by the absolute "
1700                 "simplicity of this clause of Catch-22 and let out a "
1701                 "respectful whistle. \"That's some catch, that Catch-22\", he "
1702                 "observed. \"It's the best there is,\" Doc Daneeka agreed.";
1703
1704 const char catch_22_quote[] =
1705                 "What a lousy earth! He wondered how many people were "
1706                 "destitute that same night even in his own prosperous country, "
1707                 "how many homes were shanties, how many husbands were drunk "
1708                 "and wives socked, and how many children were bullied, abused, "
1709                 "or abandoned. How many families hungered for food they could "
1710                 "not afford to buy? How many hearts were broken? How many "
1711                 "suicides would take place that same night, how many people "
1712                 "would go insane? How many cockroaches and landlords would "
1713                 "triumph? How many winners were losers, successes failures, "
1714                 "and rich men poor men? How many wise guys were stupid? How "
1715                 "many happy endings were unhappy endings? How many honest men "
1716                 "were liars, brave men cowards, loyal men traitors, how many "
1717                 "sainted men were corrupt, how many people in positions of "
1718                 "trust had sold their souls to bodyguards, how many had never "
1719                 "had souls? How many straight-and-narrow paths were crooked "
1720                 "paths? How many best families were worst families and how "
1721                 "many good people were bad people? When you added them all up "
1722                 "and then subtracted, you might be left with only the children, "
1723                 "and perhaps with Albert Einstein and an old violinist or "
1724                 "sculptor somewhere.";
1725
1726 #define QUOTE_480_BYTES         (480)
1727 #define QUOTE_512_BYTES         (512)
1728 #define QUOTE_768_BYTES         (768)
1729 #define QUOTE_1024_BYTES        (1024)
1730
1731
1732
1733 /* ***** SHA1 Hash Tests ***** */
1734
1735 #define HMAC_KEY_LENGTH_SHA1    (DIGEST_BYTE_LENGTH_SHA1)
1736
1737 static uint8_t hmac_sha1_key[] = {
1738         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
1739         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
1740         0xDE, 0xF4, 0xDE, 0xAD };
1741
1742 /* ***** SHA224 Hash Tests ***** */
1743
1744 #define HMAC_KEY_LENGTH_SHA224  (DIGEST_BYTE_LENGTH_SHA224)
1745
1746
1747 /* ***** AES-CBC Cipher Tests ***** */
1748
1749 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
1750 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
1751
1752 static uint8_t aes_cbc_key[] = {
1753         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
1754         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A };
1755
1756 static uint8_t aes_cbc_iv[] = {
1757         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
1758         0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1759
1760
1761 /* ***** AES-CBC / HMAC-SHA1 Hash Tests ***** */
1762
1763 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_ciphertext[] = {
1764         0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
1765         0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
1766         0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
1767         0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
1768         0x3F, 0x6B, 0x5D, 0xDF, 0x52, 0x85, 0x5F, 0x8E,
1769         0x42, 0x3C, 0xFB, 0xE9, 0x1A, 0x24, 0xD6, 0x08,
1770         0xDD, 0xFD, 0x16, 0xFB, 0xE9, 0x55, 0xEF, 0xF0,
1771         0xA0, 0x8D, 0x13, 0xAB, 0x81, 0xC6, 0x90, 0x01,
1772         0xB5, 0x18, 0x84, 0xB3, 0xF6, 0xE6, 0x11, 0x57,
1773         0xD6, 0x71, 0xC6, 0x3C, 0x3F, 0x2F, 0x33, 0xEE,
1774         0x24, 0x42, 0x6E, 0xAC, 0x0B, 0xCA, 0xEC, 0xF9,
1775         0x84, 0xF8, 0x22, 0xAA, 0x60, 0xF0, 0x32, 0xA9,
1776         0x75, 0x75, 0x3B, 0xCB, 0x70, 0x21, 0x0A, 0x8D,
1777         0x0F, 0xE0, 0xC4, 0x78, 0x2B, 0xF8, 0x97, 0xE3,
1778         0xE4, 0x26, 0x4B, 0x29, 0xDA, 0x88, 0xCD, 0x46,
1779         0xEC, 0xAA, 0xF9, 0x7F, 0xF1, 0x15, 0xEA, 0xC3,
1780         0x87, 0xE6, 0x31, 0xF2, 0xCF, 0xDE, 0x4D, 0x80,
1781         0x70, 0x91, 0x7E, 0x0C, 0xF7, 0x26, 0x3A, 0x92,
1782         0x4F, 0x18, 0x83, 0xC0, 0x8F, 0x59, 0x01, 0xA5,
1783         0x88, 0xD1, 0xDB, 0x26, 0x71, 0x27, 0x16, 0xF5,
1784         0xEE, 0x10, 0x82, 0xAC, 0x68, 0x26, 0x9B, 0xE2,
1785         0x6D, 0xD8, 0x9A, 0x80, 0xDF, 0x04, 0x31, 0xD5,
1786         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1787         0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
1788         0x73, 0x02, 0x42, 0xC9, 0x23, 0x18, 0x8E, 0xB4,
1789         0x6F, 0xB4, 0xA3, 0x54, 0x6E, 0x88, 0x3B, 0x62,
1790         0x7C, 0x02, 0x8D, 0x4C, 0x9F, 0xC8, 0x45, 0xF4,
1791         0xC9, 0xDE, 0x4F, 0xEB, 0x22, 0x83, 0x1B, 0xE4,
1792         0x49, 0x37, 0xE4, 0xAD, 0xE7, 0xCD, 0x21, 0x54,
1793         0xBC, 0x1C, 0xC2, 0x04, 0x97, 0xB4, 0x10, 0x61,
1794         0xF0, 0xE4, 0xEF, 0x27, 0x63, 0x3A, 0xDA, 0x91,
1795         0x41, 0x25, 0x62, 0x1C, 0x5C, 0xB6, 0x38, 0x4A,
1796         0x88, 0x71, 0x59, 0x5A, 0x8D, 0xA0, 0x09, 0xAF,
1797         0x72, 0x94, 0xD7, 0x79, 0x5C, 0x60, 0x7C, 0x8F,
1798         0x4C, 0xF5, 0xD9, 0xA1, 0x39, 0x6D, 0x81, 0x28,
1799         0xEF, 0x13, 0x28, 0xDF, 0xF5, 0x3E, 0xF7, 0x8E,
1800         0x09, 0x9C, 0x78, 0x18, 0x79, 0xB8, 0x68, 0xD7,
1801         0xA8, 0x29, 0x62, 0xAD, 0xDE, 0xE1, 0x61, 0x76,
1802         0x1B, 0x05, 0x16, 0xCD, 0xBF, 0x02, 0x8E, 0xA6,
1803         0x43, 0x6E, 0x92, 0x55, 0x4F, 0x60, 0x9C, 0x03,
1804         0xB8, 0x4F, 0xA3, 0x02, 0xAC, 0xA8, 0xA7, 0x0C,
1805         0x1E, 0xB5, 0x6B, 0xF8, 0xC8, 0x4D, 0xDE, 0xD2,
1806         0xB0, 0x29, 0x6E, 0x40, 0xE6, 0xD6, 0xC9, 0xE6,
1807         0xB9, 0x0F, 0xB6, 0x63, 0xF5, 0xAA, 0x2B, 0x96,
1808         0xA7, 0x16, 0xAC, 0x4E, 0x0A, 0x33, 0x1C, 0xA6,
1809         0xE6, 0xBD, 0x8A, 0xCF, 0x40, 0xA9, 0xB2, 0xFA,
1810         0x63, 0x27, 0xFD, 0x9B, 0xD9, 0xFC, 0xD5, 0x87,
1811         0x8D, 0x4C, 0xB6, 0xA4, 0xCB, 0xE7, 0x74, 0x55,
1812         0xF4, 0xFB, 0x41, 0x25, 0xB5, 0x4B, 0x0A, 0x1B,
1813         0xB1, 0xD6, 0xB7, 0xD9, 0x47, 0x2A, 0xC3, 0x98,
1814         0x6A, 0xC4, 0x03, 0x73, 0x1F, 0x93, 0x6E, 0x53,
1815         0x19, 0x25, 0x64, 0x15, 0x83, 0xF9, 0x73, 0x2A,
1816         0x74, 0xB4, 0x93, 0x69, 0xC4, 0x72, 0xFC, 0x26,
1817         0xA2, 0x9F, 0x43, 0x45, 0xDD, 0xB9, 0xEF, 0x36,
1818         0xC8, 0x3A, 0xCD, 0x99, 0x9B, 0x54, 0x1A, 0x36,
1819         0xC1, 0x59, 0xF8, 0x98, 0xA8, 0xCC, 0x28, 0x0D,
1820         0x73, 0x4C, 0xEE, 0x98, 0xCB, 0x7C, 0x58, 0x7E,
1821         0x20, 0x75, 0x1E, 0xB7, 0xC9, 0xF8, 0xF2, 0x0E,
1822         0x63, 0x9E, 0x05, 0x78, 0x1A, 0xB6, 0xA8, 0x7A,
1823         0xF9, 0x98, 0x6A, 0xA6, 0x46, 0x84, 0x2E, 0xF6,
1824         0x4B, 0xDC, 0x9B, 0x8F, 0x9B, 0x8F, 0xEE, 0xB4,
1825         0xAA, 0x3F, 0xEE, 0xC0, 0x37, 0x27, 0x76, 0xC7,
1826         0x95, 0xBB, 0x26, 0x74, 0x69, 0x12, 0x7F, 0xF1,
1827         0xBB, 0xFF, 0xAE, 0xB5, 0x99, 0x6E, 0xCB, 0x0C
1828 };
1829
1830 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest[] = {
1831         0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60,
1832         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
1833         0x18, 0x8c, 0x1d, 0x32
1834 };
1835
1836
1837 /* Multisession Vector context Test */
1838 /*Begin Session 0 */
1839 static uint8_t ms_aes_cbc_key0[] = {
1840         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1841         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1842 };
1843
1844 static uint8_t ms_aes_cbc_iv0[] = {
1845         0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1846         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1847 };
1848
1849 static const uint8_t ms_aes_cbc_cipher0[] = {
1850                 0x3C, 0xE4, 0xEE, 0x42, 0xB6, 0x9B, 0xC3, 0x38,
1851                 0x5F, 0xAD, 0x54, 0xDC, 0xA8, 0x32, 0x81, 0xDC,
1852                 0x7A, 0x6F, 0x85, 0x58, 0x07, 0x35, 0xED, 0xEB,
1853                 0xAD, 0x79, 0x79, 0x96, 0xD3, 0x0E, 0xA6, 0xD9,
1854                 0xAA, 0x86, 0xA4, 0x8F, 0xB5, 0xD6, 0x6E, 0x6D,
1855                 0x0C, 0x91, 0x2F, 0xC4, 0x67, 0x98, 0x0E, 0xC4,
1856                 0x8D, 0x83, 0x68, 0x69, 0xC4, 0xD3, 0x94, 0x34,
1857                 0xC4, 0x5D, 0x60, 0x55, 0x22, 0x87, 0x8F, 0x6F,
1858                 0x17, 0x8E, 0x75, 0xE4, 0x02, 0xF5, 0x1B, 0x99,
1859                 0xC8, 0x39, 0xA9, 0xAB, 0x23, 0x91, 0x12, 0xED,
1860                 0x08, 0xE7, 0xD9, 0x25, 0x89, 0x24, 0x4F, 0x8D,
1861                 0x68, 0xF3, 0x10, 0x39, 0x0A, 0xEE, 0x45, 0x24,
1862                 0xDF, 0x7A, 0x9D, 0x00, 0x25, 0xE5, 0x35, 0x71,
1863                 0x4E, 0x40, 0x59, 0x6F, 0x0A, 0x13, 0xB3, 0x72,
1864                 0x1D, 0x98, 0x63, 0x94, 0x89, 0xA5, 0x39, 0x8E,
1865                 0xD3, 0x9C, 0x8A, 0x7F, 0x71, 0x2F, 0xC7, 0xCD,
1866                 0x81, 0x05, 0xDC, 0xC0, 0x8D, 0xCE, 0x6D, 0x18,
1867                 0x30, 0xC4, 0x72, 0x51, 0xF0, 0x27, 0xC8, 0xF6,
1868                 0x60, 0x5B, 0x7C, 0xB2, 0xE3, 0x49, 0x0C, 0x29,
1869                 0xC6, 0x9F, 0x39, 0x57, 0x80, 0x55, 0x24, 0x2C,
1870                 0x9B, 0x0F, 0x5A, 0xB3, 0x89, 0x55, 0x31, 0x96,
1871                 0x0D, 0xCD, 0xF6, 0x51, 0x03, 0x2D, 0x89, 0x26,
1872                 0x74, 0x44, 0xD6, 0xE8, 0xDC, 0xEA, 0x44, 0x55,
1873                 0x64, 0x71, 0x9C, 0x9F, 0x5D, 0xBA, 0x39, 0x46,
1874                 0xA8, 0x17, 0xA1, 0x9C, 0x52, 0x9D, 0xBC, 0x6B,
1875                 0x4A, 0x98, 0xE6, 0xEA, 0x33, 0xEC, 0x58, 0xB4,
1876                 0x43, 0xF0, 0x32, 0x45, 0xA4, 0xC1, 0x55, 0xB7,
1877                 0x5D, 0xB5, 0x59, 0xB2, 0xE3, 0x96, 0xFF, 0xA5,
1878                 0xAF, 0xE1, 0x86, 0x1B, 0x42, 0xE6, 0x3B, 0xA0,
1879                 0x90, 0x4A, 0xE8, 0x8C, 0x21, 0x7F, 0x36, 0x1E,
1880                 0x5B, 0x65, 0x25, 0xD1, 0xC1, 0x5A, 0xCA, 0x3D,
1881                 0x10, 0xED, 0x2D, 0x79, 0xD0, 0x0F, 0x58, 0x44,
1882                 0x69, 0x81, 0xF5, 0xD4, 0xC9, 0x0F, 0x90, 0x76,
1883                 0x1F, 0x54, 0xD2, 0xD5, 0x97, 0xCE, 0x2C, 0xE3,
1884                 0xEF, 0xF4, 0xB7, 0xC6, 0x3A, 0x87, 0x7F, 0x83,
1885                 0x2A, 0xAF, 0xCD, 0x90, 0x12, 0xA7, 0x7D, 0x85,
1886                 0x1D, 0x62, 0xD3, 0x85, 0x25, 0x05, 0xDB, 0x45,
1887                 0x92, 0xA3, 0xF6, 0xA2, 0xA8, 0x41, 0xE4, 0x25,
1888                 0x86, 0x87, 0x67, 0x24, 0xEC, 0x89, 0x23, 0x2A,
1889                 0x9B, 0x20, 0x4D, 0x93, 0xEE, 0xE2, 0x2E, 0xC1,
1890                 0x0B, 0x15, 0x33, 0xCF, 0x00, 0xD1, 0x1A, 0xDA,
1891                 0x93, 0xFD, 0x28, 0x21, 0x5B, 0xCF, 0xD1, 0xF3,
1892                 0x5A, 0x81, 0xBA, 0x82, 0x5E, 0x2F, 0x61, 0xB4,
1893                 0x05, 0x71, 0xB5, 0xF4, 0x39, 0x3C, 0x1F, 0x60,
1894                 0x00, 0x7A, 0xC4, 0xF8, 0x35, 0x20, 0x6C, 0x3A,
1895                 0xCC, 0x03, 0x8F, 0x7B, 0xA2, 0xB6, 0x65, 0x8A,
1896                 0xB6, 0x5F, 0xFD, 0x25, 0xD3, 0x5F, 0x92, 0xF9,
1897                 0xAE, 0x17, 0x9B, 0x5E, 0x6E, 0x9A, 0xE4, 0x55,
1898                 0x10, 0x25, 0x07, 0xA4, 0xAF, 0x21, 0x69, 0x13,
1899                 0xD8, 0xFA, 0x31, 0xED, 0xF7, 0xA7, 0xA7, 0x3B,
1900                 0xB8, 0x96, 0x8E, 0x10, 0x86, 0x74, 0xD8, 0xB1,
1901                 0x34, 0x9E, 0x9B, 0x6A, 0x26, 0xA8, 0xD4, 0xD0,
1902                 0xB5, 0xF6, 0xDE, 0xE7, 0xCA, 0x06, 0xDC, 0xA3,
1903                 0x6F, 0xEE, 0x6B, 0x1E, 0xB5, 0x30, 0x99, 0x23,
1904                 0xF9, 0x76, 0xF0, 0xA0, 0xCF, 0x3B, 0x94, 0x7B,
1905                 0x19, 0x8D, 0xA5, 0x0C, 0x18, 0xA6, 0x1D, 0x07,
1906                 0x89, 0xBE, 0x5B, 0x61, 0xE5, 0xF1, 0x42, 0xDB,
1907                 0xD4, 0x2E, 0x02, 0x1F, 0xCE, 0xEF, 0x92, 0xB1,
1908                 0x1B, 0x56, 0x50, 0xF2, 0x16, 0xE5, 0xE7, 0x4F,
1909                 0xFD, 0xBB, 0x3E, 0xD2, 0xFC, 0x3C, 0xC6, 0x0F,
1910                 0xF9, 0x12, 0x4E, 0xCB, 0x1E, 0x0C, 0x15, 0x84,
1911                 0x2A, 0x14, 0x8A, 0x02, 0xE4, 0x7E, 0x95, 0x5B,
1912                 0x86, 0xDB, 0x9B, 0x62, 0x5B, 0x19, 0xD2, 0x17,
1913                 0xFA, 0x13, 0xBB, 0x6B, 0x3F, 0x45, 0x9F, 0xBF
1914 };
1915
1916
1917 static  uint8_t ms_hmac_key0[] = {
1918                 0xFF, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
1919                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
1920                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
1921                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
1922                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
1923                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
1924                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
1925                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
1926 };
1927
1928 static const uint8_t ms_hmac_digest0[] = {
1929                 0x43, 0x52, 0xED, 0x34, 0xAB, 0x36, 0xB2, 0x51,
1930                 0xFB, 0xA3, 0xA6, 0x7C, 0x38, 0xFC, 0x42, 0x8F,
1931                 0x57, 0x64, 0xAB, 0x81, 0xA7, 0x89, 0xB7, 0x6C,
1932                 0xA0, 0xDC, 0xB9, 0x4D, 0xC4, 0x30, 0xF9, 0xD4,
1933                 0x10, 0x82, 0x55, 0xD0, 0xAB, 0x32, 0xFB, 0x56,
1934                 0x0D, 0xE4, 0x68, 0x3D, 0x76, 0xD0, 0x7B, 0xE4,
1935                 0xA6, 0x2C, 0x34, 0x9E, 0x8C, 0x41, 0xF8, 0x23,
1936                 0x28, 0x1B, 0x3A, 0x90, 0x26, 0x34, 0x47, 0x90
1937                 };
1938
1939 /* End Session 0 */
1940 /* Begin session 1 */
1941
1942 static  uint8_t ms_aes_cbc_key1[] = {
1943                 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1944                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1945 };
1946
1947 static  uint8_t ms_aes_cbc_iv1[] = {
1948         0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
1949         0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
1950 };
1951
1952 static const uint8_t ms_aes_cbc_cipher1[] = {
1953                 0x5A, 0x7A, 0x67, 0x5D, 0xB8, 0xE1, 0xDC, 0x71,
1954                 0x39, 0xA8, 0x74, 0x93, 0x9C, 0x4C, 0xFE, 0x23,
1955                 0x61, 0xCD, 0xA4, 0xB3, 0xD9, 0xCE, 0x99, 0x09,
1956                 0x2A, 0x23, 0xF3, 0x29, 0xBF, 0x4C, 0xB4, 0x6A,
1957                 0x1B, 0x6B, 0x73, 0x4D, 0x48, 0x0C, 0xCF, 0x6C,
1958                 0x5E, 0x34, 0x9E, 0x7F, 0xBC, 0x8F, 0xCC, 0x8F,
1959                 0x75, 0x1D, 0x3D, 0x77, 0x10, 0x76, 0xC8, 0xB9,
1960                 0x99, 0x6F, 0xD6, 0x56, 0x75, 0xA9, 0xB2, 0x66,
1961                 0xC2, 0x24, 0x2B, 0x9C, 0xFE, 0x40, 0x8E, 0x43,
1962                 0x20, 0x97, 0x1B, 0xFA, 0xD0, 0xCF, 0x04, 0xAB,
1963                 0xBB, 0xF6, 0x5D, 0xF5, 0xA0, 0x19, 0x7C, 0x23,
1964                 0x5D, 0x80, 0x8C, 0x49, 0xF6, 0x76, 0x88, 0x29,
1965                 0x27, 0x4C, 0x59, 0x2B, 0x43, 0xA6, 0xB2, 0x26,
1966                 0x27, 0x78, 0xBE, 0x1B, 0xE1, 0x4F, 0x5A, 0x1F,
1967                 0xFC, 0x68, 0x08, 0xE7, 0xC4, 0xD1, 0x34, 0x68,
1968                 0xB7, 0x13, 0x14, 0x41, 0x62, 0x6B, 0x1F, 0x77,
1969                 0x0C, 0x68, 0x1D, 0x0D, 0xED, 0x89, 0xAA, 0xD8,
1970                 0x97, 0x02, 0xBA, 0x5E, 0xD4, 0x84, 0x25, 0x97,
1971                 0x03, 0xA5, 0xA6, 0x13, 0x66, 0x02, 0xF4, 0xC3,
1972                 0xF3, 0xD3, 0xCC, 0x95, 0xC3, 0x87, 0x46, 0x90,
1973                 0x1F, 0x6E, 0x14, 0xA8, 0x00, 0xF2, 0x6F, 0xD5,
1974                 0xA1, 0xAD, 0xD5, 0x40, 0xA2, 0x0F, 0x32, 0x7E,
1975                 0x99, 0xA3, 0xF5, 0x53, 0xC3, 0x26, 0xA1, 0x45,
1976                 0x01, 0x88, 0x57, 0x84, 0x3E, 0x7B, 0x4E, 0x0B,
1977                 0x3C, 0xB5, 0x3E, 0x9E, 0xE9, 0x78, 0x77, 0xC5,
1978                 0xC0, 0x89, 0xA8, 0xF8, 0xF1, 0xA5, 0x2D, 0x5D,
1979                 0xF9, 0xC6, 0xFB, 0xCB, 0x05, 0x23, 0xBD, 0x6E,
1980                 0x5E, 0x14, 0xC6, 0x57, 0x73, 0xCF, 0x98, 0xBD,
1981                 0x10, 0x8B, 0x18, 0xA6, 0x01, 0x5B, 0x13, 0xAE,
1982                 0x8E, 0xDE, 0x1F, 0xB5, 0xB7, 0x40, 0x6C, 0xC1,
1983                 0x1E, 0xA1, 0x19, 0x20, 0x9E, 0x95, 0xE0, 0x2F,
1984                 0x1C, 0xF5, 0xD9, 0xD0, 0x2B, 0x1E, 0x82, 0x25,
1985                 0x62, 0xB4, 0xEB, 0xA1, 0x1F, 0xCE, 0x44, 0xA1,
1986                 0xCB, 0x92, 0x01, 0x6B, 0xE4, 0x26, 0x23, 0xE3,
1987                 0xC5, 0x67, 0x35, 0x55, 0xDA, 0xE5, 0x27, 0xEE,
1988                 0x8D, 0x12, 0x84, 0xB7, 0xBA, 0xA7, 0x1C, 0xD6,
1989                 0x32, 0x3F, 0x67, 0xED, 0xFB, 0x5B, 0x8B, 0x52,
1990                 0x46, 0x8C, 0xF9, 0x69, 0xCD, 0xAE, 0x79, 0xAA,
1991                 0x37, 0x78, 0x49, 0xEB, 0xC6, 0x8E, 0x76, 0x63,
1992                 0x84, 0xFF, 0x9D, 0x22, 0x99, 0x51, 0xB7, 0x5E,
1993                 0x83, 0x4C, 0x8B, 0xDF, 0x5A, 0x07, 0xCC, 0xBA,
1994                 0x42, 0xA5, 0x98, 0xB6, 0x47, 0x0E, 0x66, 0xEB,
1995                 0x23, 0x0E, 0xBA, 0x44, 0xA8, 0xAA, 0x20, 0x71,
1996                 0x79, 0x9C, 0x77, 0x5F, 0xF5, 0xFE, 0xEC, 0xEF,
1997                 0xC6, 0x64, 0x3D, 0x84, 0xD0, 0x2B, 0xA7, 0x0A,
1998                 0xC3, 0x72, 0x5B, 0x9C, 0xFA, 0xA8, 0x87, 0x95,
1999                 0x94, 0x11, 0x38, 0xA7, 0x1E, 0x58, 0xE3, 0x73,
2000                 0xC6, 0xC9, 0xD1, 0x7B, 0x92, 0xDB, 0x0F, 0x49,
2001                 0x74, 0xC2, 0xA2, 0x0E, 0x35, 0x57, 0xAC, 0xDB,
2002                 0x9A, 0x1C, 0xCF, 0x5A, 0x32, 0x3E, 0x26, 0x9B,
2003                 0xEC, 0xB3, 0xEF, 0x9C, 0xFE, 0xBE, 0x52, 0xAC,
2004                 0xB1, 0x29, 0xDD, 0xFD, 0x07, 0xE2, 0xEE, 0xED,
2005                 0xE4, 0x46, 0x37, 0xFE, 0xD1, 0xDC, 0xCD, 0x02,
2006                 0xF9, 0x31, 0xB0, 0xFB, 0x36, 0xB7, 0x34, 0xA4,
2007                 0x76, 0xE8, 0x57, 0xBF, 0x99, 0x92, 0xC7, 0xAF,
2008                 0x98, 0x10, 0xE2, 0x70, 0xCA, 0xC9, 0x2B, 0x82,
2009                 0x06, 0x96, 0x88, 0x0D, 0xB3, 0xAC, 0x9E, 0x6D,
2010                 0x43, 0xBC, 0x5B, 0x31, 0xCF, 0x65, 0x8D, 0xA6,
2011                 0xC7, 0xFE, 0x73, 0xE1, 0x54, 0xF7, 0x10, 0xF9,
2012                 0x86, 0xF7, 0xDF, 0xA1, 0xA1, 0xD8, 0xAE, 0x35,
2013                 0xB3, 0x90, 0xDC, 0x6F, 0x43, 0x7A, 0x8B, 0xE0,
2014                 0xFE, 0x8F, 0x33, 0x4D, 0x29, 0x6C, 0x45, 0x53,
2015                 0x73, 0xDD, 0x21, 0x0B, 0x85, 0x30, 0xB5, 0xA5,
2016                 0xF3, 0x5D, 0xEC, 0x79, 0x61, 0x9D, 0x9E, 0xB3
2017
2018 };
2019
2020 static uint8_t ms_hmac_key1[] = {
2021                 0xFE, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2022                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2023                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2024                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2025                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2026                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2027                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2028                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2029 };
2030
2031 static const uint8_t ms_hmac_digest1[] = {
2032                 0xCE, 0x6E, 0x5F, 0x77, 0x96, 0x9A, 0xB1, 0x69,
2033                 0x2D, 0x5E, 0xF3, 0x2F, 0x32, 0x10, 0xCB, 0x50,
2034                 0x0E, 0x09, 0x56, 0x25, 0x07, 0x34, 0xC9, 0x20,
2035                 0xEC, 0x13, 0x43, 0x23, 0x5C, 0x08, 0x8B, 0xCD,
2036                 0xDC, 0x86, 0x8C, 0xEE, 0x0A, 0x95, 0x2E, 0xB9,
2037                 0x8C, 0x7B, 0x02, 0x7A, 0xD4, 0xE1, 0x49, 0xB4,
2038                 0x45, 0xB5, 0x52, 0x37, 0xC6, 0xFF, 0xFE, 0xAA,
2039                 0x0A, 0x87, 0xB8, 0x51, 0xF9, 0x2A, 0x01, 0x8F
2040 };
2041 /* End Session 1  */
2042 /* Begin Session 2 */
2043 static  uint8_t ms_aes_cbc_key2[] = {
2044                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2045                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2046 };
2047
2048 static  uint8_t ms_aes_cbc_iv2[] = {
2049                 0xff, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
2050                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
2051 };
2052
2053 static const uint8_t ms_aes_cbc_cipher2[] = {
2054                 0xBB, 0x3C, 0x68, 0x25, 0xFD, 0xB6, 0xA2, 0x91,
2055                 0x20, 0x56, 0xF6, 0x30, 0x35, 0xFC, 0x9E, 0x97,
2056                 0xF2, 0x90, 0xFC, 0x7E, 0x3E, 0x0A, 0x75, 0xC8,
2057                 0x4C, 0xF2, 0x2D, 0xAC, 0xD3, 0x93, 0xF0, 0xC5,
2058                 0x14, 0x88, 0x8A, 0x23, 0xC2, 0x59, 0x9A, 0x98,
2059                 0x4B, 0xD5, 0x2C, 0xDA, 0x43, 0xA9, 0x34, 0x69,
2060                 0x7C, 0x6D, 0xDB, 0xDC, 0xCB, 0xC0, 0xA0, 0x09,
2061                 0xA7, 0x86, 0x16, 0x4B, 0xBF, 0xA8, 0xB6, 0xCF,
2062                 0x7F, 0x74, 0x1F, 0x22, 0xF0, 0xF6, 0xBB, 0x44,
2063                 0x8B, 0x4C, 0x9E, 0x23, 0xF8, 0x9F, 0xFC, 0x5B,
2064                 0x9E, 0x9C, 0x2A, 0x79, 0x30, 0x8F, 0xBF, 0xA9,
2065                 0x68, 0xA1, 0x20, 0x71, 0x7C, 0x77, 0x22, 0x34,
2066                 0x07, 0xCD, 0xC6, 0xF6, 0x50, 0x0A, 0x08, 0x99,
2067                 0x17, 0x98, 0xE3, 0x93, 0x8A, 0xB0, 0xEE, 0xDF,
2068                 0xC2, 0xBA, 0x3B, 0x44, 0x73, 0xDF, 0xDD, 0xDC,
2069                 0x14, 0x4D, 0x3B, 0xBB, 0x5E, 0x58, 0xC1, 0x26,
2070                 0xA7, 0xAE, 0x47, 0xF3, 0x24, 0x6D, 0x4F, 0xD3,
2071                 0x6E, 0x3E, 0x33, 0xE6, 0x7F, 0xCA, 0x50, 0xAF,
2072                 0x5D, 0x3D, 0xA0, 0xDD, 0xC9, 0xF3, 0x30, 0xD3,
2073                 0x6E, 0x8B, 0x2E, 0x12, 0x24, 0x34, 0xF0, 0xD3,
2074                 0xC7, 0x8D, 0x23, 0x29, 0xAA, 0x05, 0xE1, 0xFA,
2075                 0x2E, 0xF6, 0x8D, 0x37, 0x86, 0xC0, 0x6D, 0x13,
2076                 0x2D, 0x98, 0xF3, 0x52, 0x39, 0x22, 0xCE, 0x38,
2077                 0xC2, 0x1A, 0x72, 0xED, 0xFB, 0xCC, 0xE4, 0x71,
2078                 0x5A, 0x0C, 0x0D, 0x09, 0xF8, 0xE8, 0x1B, 0xBC,
2079                 0x53, 0xC8, 0xD8, 0x8F, 0xE5, 0x98, 0x5A, 0xB1,
2080                 0x06, 0xA6, 0x5B, 0xE6, 0xA2, 0x88, 0x21, 0x9E,
2081                 0x36, 0xC0, 0x34, 0xF9, 0xFB, 0x3B, 0x0A, 0x22,
2082                 0x00, 0x00, 0x39, 0x48, 0x8D, 0x23, 0x74, 0x62,
2083                 0x72, 0x91, 0xE6, 0x36, 0xAA, 0x77, 0x9C, 0x72,
2084                 0x9D, 0xA8, 0xC3, 0xA9, 0xD5, 0x44, 0x72, 0xA6,
2085                 0xB9, 0x28, 0x8F, 0x64, 0x4C, 0x8A, 0x64, 0xE6,
2086                 0x4E, 0xFA, 0xEF, 0x87, 0xDE, 0x7B, 0x22, 0x44,
2087                 0xB0, 0xDF, 0x2E, 0x5F, 0x0B, 0xA5, 0xF2, 0x24,
2088                 0x07, 0x5C, 0x2D, 0x39, 0xB7, 0x3D, 0x8A, 0xE5,
2089                 0x0E, 0x9D, 0x4E, 0x50, 0xED, 0x03, 0x99, 0x8E,
2090                 0xF0, 0x06, 0x55, 0x4E, 0xA2, 0x24, 0xE7, 0x17,
2091                 0x46, 0xDF, 0x6C, 0xCD, 0xC6, 0x44, 0xE8, 0xF9,
2092                 0xB9, 0x1B, 0x36, 0xF6, 0x7F, 0x10, 0xA4, 0x7D,
2093                 0x90, 0xBD, 0xE4, 0xAA, 0xD6, 0x9E, 0x18, 0x9D,
2094                 0x22, 0x35, 0xD6, 0x55, 0x54, 0xAA, 0xF7, 0x22,
2095                 0xA3, 0x3E, 0xEF, 0xC8, 0xA2, 0x34, 0x8D, 0xA9,
2096                 0x37, 0x63, 0xA6, 0xC3, 0x57, 0xCB, 0x0C, 0x49,
2097                 0x7D, 0x02, 0xBE, 0xAA, 0x13, 0x75, 0xB7, 0x4E,
2098                 0x52, 0x62, 0xA5, 0xC2, 0x33, 0xC7, 0x6C, 0x1B,
2099                 0xF6, 0x34, 0xF6, 0x09, 0xA5, 0x0C, 0xC7, 0xA2,
2100                 0x61, 0x48, 0x62, 0x7D, 0x17, 0x15, 0xE3, 0x95,
2101                 0xC8, 0x63, 0xD2, 0xA4, 0x43, 0xA9, 0x49, 0x07,
2102                 0xB2, 0x3B, 0x2B, 0x62, 0x7D, 0xCB, 0x51, 0xB3,
2103                 0x25, 0x33, 0x47, 0x0E, 0x14, 0x67, 0xDC, 0x6A,
2104                 0x9B, 0x51, 0xAC, 0x9D, 0x8F, 0xA2, 0x2B, 0x57,
2105                 0x8C, 0x5C, 0x5F, 0x76, 0x23, 0x92, 0x0F, 0x84,
2106                 0x46, 0x0E, 0x40, 0x85, 0x38, 0x60, 0xFA, 0x61,
2107                 0x20, 0xC5, 0xE3, 0xF1, 0x70, 0xAC, 0x1B, 0xBF,
2108                 0xC4, 0x2B, 0xC5, 0x67, 0xD1, 0x43, 0xC5, 0x17,
2109                 0x74, 0x71, 0x69, 0x6F, 0x82, 0x89, 0x19, 0x8A,
2110                 0x70, 0x43, 0x92, 0x01, 0xC4, 0x63, 0x7E, 0xB1,
2111                 0x59, 0x4E, 0xCD, 0xEA, 0x93, 0xA4, 0x52, 0x53,
2112                 0x9B, 0x61, 0x5B, 0xD2, 0x3E, 0x19, 0x39, 0xB7,
2113                 0x32, 0xEA, 0x8E, 0xF8, 0x1D, 0x76, 0x5C, 0xB2,
2114                 0x73, 0x2D, 0x91, 0xC0, 0x18, 0xED, 0x25, 0x2A,
2115                 0x53, 0x64, 0xF0, 0x92, 0x31, 0x55, 0x21, 0xA8,
2116                 0x24, 0xA9, 0xD1, 0x02, 0xF6, 0x6C, 0x2B, 0x70,
2117                 0xA9, 0x59, 0xC1, 0xD6, 0xC3, 0x57, 0x5B, 0x92
2118 };
2119
2120 static  uint8_t ms_hmac_key2[] = {
2121                 0xFC, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
2122                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2123                 0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2124                 0x9A, 0xAF, 0x88, 0x1B, 0xB6, 0x8F, 0xF8, 0x60,
2125                 0xA2, 0x5A, 0x7F, 0x3F, 0xF4, 0x72, 0x70, 0xF1,
2126                 0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2127                 0x47, 0x3A, 0x75, 0x61, 0x5C, 0xA2, 0x10, 0x76,
2128                 0x9A, 0xAF, 0x77, 0x5B, 0xB6, 0x7F, 0xF7, 0x60
2129 };
2130
2131 static const uint8_t ms_hmac_digest2[] = {
2132                 0xA5, 0x0F, 0x9C, 0xFB, 0x08, 0x62, 0x59, 0xFF,
2133                 0x80, 0x2F, 0xEB, 0x4B, 0xE1, 0x46, 0x21, 0xD6,
2134                 0x02, 0x98, 0xF2, 0x8E, 0xF4, 0xEC, 0xD4, 0x77,
2135                 0x86, 0x4C, 0x31, 0x28, 0xC8, 0x25, 0x80, 0x27,
2136                 0x3A, 0x72, 0x5D, 0x6A, 0x56, 0x8A, 0xD3, 0x82,
2137                 0xB0, 0xEC, 0x31, 0x6D, 0x8B, 0x6B, 0xB4, 0x24,
2138                 0xE7, 0x62, 0xC1, 0x52, 0xBC, 0x14, 0x1B, 0x8E,
2139                 0xEC, 0x9A, 0xF1, 0x47, 0x80, 0xD2, 0xB0, 0x59
2140 };
2141
2142 /* End Session 2 */
2143
2144
2145 static int
2146 test_AES_CBC_HMAC_SHA1_encrypt_digest(void)
2147 {
2148         struct crypto_testsuite_params *ts_params = &testsuite_params;
2149         struct crypto_unittest_params *ut_params = &unittest_params;
2150         int status;
2151
2152         /* Verify the capabilities */
2153         struct rte_cryptodev_sym_capability_idx cap_idx;
2154         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2155         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
2156         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2157                         &cap_idx) == NULL)
2158                 return TEST_SKIPPED;
2159         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2160         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
2161         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
2162                         &cap_idx) == NULL)
2163                 return TEST_SKIPPED;
2164
2165         /* Generate test mbuf data and space for digest */
2166         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2167                         catch_22_quote, QUOTE_512_BYTES, 0);
2168
2169         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2170                         DIGEST_BYTE_LENGTH_SHA1);
2171         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2172
2173         /* Setup Cipher Parameters */
2174         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2175         ut_params->cipher_xform.next = &ut_params->auth_xform;
2176
2177         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2178         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2179         ut_params->cipher_xform.cipher.key.data = aes_cbc_key;
2180         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2181         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2182         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2183
2184         /* Setup HMAC Parameters */
2185         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2186
2187         ut_params->auth_xform.next = NULL;
2188
2189         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2190         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
2191         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA1;
2192         ut_params->auth_xform.auth.key.data = hmac_sha1_key;
2193         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA1;
2194
2195         ut_params->sess = rte_cryptodev_sym_session_create(
2196                         ts_params->session_mpool);
2197         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2198
2199         /* Create crypto session*/
2200         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
2201                         ut_params->sess, &ut_params->cipher_xform,
2202                         ts_params->session_priv_mpool);
2203
2204         if (status == -ENOTSUP)
2205                 return TEST_SKIPPED;
2206
2207         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
2208
2209         /* Generate crypto op data structure */
2210         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2211                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2212         TEST_ASSERT_NOT_NULL(ut_params->op,
2213                         "Failed to allocate symmetric crypto operation struct");
2214
2215         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2216
2217         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2218
2219         /* set crypto operation source mbuf */
2220         sym_op->m_src = ut_params->ibuf;
2221
2222         /* Set crypto operation authentication parameters */
2223         sym_op->auth.digest.data = ut_params->digest;
2224         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2225                         ut_params->ibuf, QUOTE_512_BYTES);
2226
2227         sym_op->auth.data.offset = 0;
2228         sym_op->auth.data.length = QUOTE_512_BYTES;
2229
2230         /* Copy IV at the end of the crypto operation */
2231         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2232                         aes_cbc_iv, CIPHER_IV_LENGTH_AES_CBC);
2233
2234         /* Set crypto operation cipher parameters */
2235         sym_op->cipher.data.offset = 0;
2236         sym_op->cipher.data.length = QUOTE_512_BYTES;
2237
2238         /* Process crypto operation */
2239         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2240                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2241                         ut_params->op);
2242         else
2243                 TEST_ASSERT_NOT_NULL(
2244                         process_crypto_request(ts_params->valid_devs[0],
2245                                 ut_params->op),
2246                                 "failed to process sym crypto op");
2247
2248         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2249                         "crypto op processing failed");
2250
2251         /* Validate obuf */
2252         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
2253                         uint8_t *);
2254
2255         TEST_ASSERT_BUFFERS_ARE_EQUAL(ciphertext,
2256                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
2257                         QUOTE_512_BYTES,
2258                         "ciphertext data not as expected");
2259
2260         uint8_t *digest = ciphertext + QUOTE_512_BYTES;
2261
2262         TEST_ASSERT_BUFFERS_ARE_EQUAL(digest,
2263                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA1_digest,
2264                         gbl_driver_id == rte_cryptodev_driver_id_get(
2265                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) ?
2266                                         TRUNCATED_DIGEST_BYTE_LENGTH_SHA1 :
2267                                         DIGEST_BYTE_LENGTH_SHA1,
2268                         "Generated digest data not as expected");
2269
2270         return TEST_SUCCESS;
2271 }
2272
2273 /* ***** AES-CBC / HMAC-SHA512 Hash Tests ***** */
2274
2275 #define HMAC_KEY_LENGTH_SHA512  (DIGEST_BYTE_LENGTH_SHA512)
2276
2277 static uint8_t hmac_sha512_key[] = {
2278         0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1,
2279         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA,
2280         0x58, 0x34, 0x85, 0x65, 0x1C, 0x42, 0x50, 0x76,
2281         0x9a, 0xaf, 0x88, 0x1b, 0xb6, 0x8f, 0xf8, 0x60,
2282         0xa2, 0x5a, 0x7f, 0x3f, 0xf4, 0x72, 0x70, 0xf1,
2283         0xF5, 0x35, 0x4C, 0x3B, 0xDD, 0x90, 0x65, 0xB0,
2284         0x47, 0x3a, 0x75, 0x61, 0x5C, 0xa2, 0x10, 0x76,
2285         0x9a, 0xaf, 0x77, 0x5b, 0xb6, 0x7f, 0xf7, 0x60 };
2286
2287 static const uint8_t catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest[] = {
2288         0x5D, 0x54, 0x66, 0xC1, 0x6E, 0xBC, 0x04, 0xB8,
2289         0x46, 0xB8, 0x08, 0x6E, 0xE0, 0xF0, 0x43, 0x48,
2290         0x37, 0x96, 0x9C, 0xC6, 0x9C, 0xC2, 0x1E, 0xE8,
2291         0xF2, 0x0C, 0x0B, 0xEF, 0x86, 0xA2, 0xE3, 0x70,
2292         0x95, 0xC8, 0xB3, 0x06, 0x47, 0xA9, 0x90, 0xE8,
2293         0xA0, 0xC6, 0x72, 0x69, 0x05, 0xC0, 0x0D, 0x0E,
2294         0x21, 0x96, 0x65, 0x93, 0x74, 0x43, 0x2A, 0x1D,
2295         0x2E, 0xBF, 0xC2, 0xC2, 0xEE, 0xCC, 0x2F, 0x0A };
2296
2297
2298
2299 static int
2300 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2301                 struct crypto_unittest_params *ut_params,
2302                 uint8_t *cipher_key,
2303                 uint8_t *hmac_key);
2304
2305 static int
2306 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2307                 struct crypto_unittest_params *ut_params,
2308                 struct crypto_testsuite_params *ts_params,
2309                 const uint8_t *cipher,
2310                 const uint8_t *digest,
2311                 const uint8_t *iv);
2312
2313
2314 static int
2315 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
2316                 struct crypto_unittest_params *ut_params,
2317                 uint8_t *cipher_key,
2318                 uint8_t *hmac_key)
2319 {
2320
2321         /* Setup Cipher Parameters */
2322         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2323         ut_params->cipher_xform.next = NULL;
2324
2325         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
2326         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2327         ut_params->cipher_xform.cipher.key.data = cipher_key;
2328         ut_params->cipher_xform.cipher.key.length = CIPHER_KEY_LENGTH_AES_CBC;
2329         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2330         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2331
2332         /* Setup HMAC Parameters */
2333         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2334         ut_params->auth_xform.next = &ut_params->cipher_xform;
2335
2336         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
2337         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA512_HMAC;
2338         ut_params->auth_xform.auth.key.data = hmac_key;
2339         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA512;
2340         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA512;
2341
2342         return TEST_SUCCESS;
2343 }
2344
2345
2346 static int
2347 test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess,
2348                 struct crypto_unittest_params *ut_params,
2349                 struct crypto_testsuite_params *ts_params,
2350                 const uint8_t *cipher,
2351                 const uint8_t *digest,
2352                 const uint8_t *iv)
2353 {
2354         /* Generate test mbuf data and digest */
2355         ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
2356                         (const char *)
2357                         cipher,
2358                         QUOTE_512_BYTES, 0);
2359
2360         ut_params->digest = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
2361                         DIGEST_BYTE_LENGTH_SHA512);
2362         TEST_ASSERT_NOT_NULL(ut_params->digest, "no room to append digest");
2363
2364         rte_memcpy(ut_params->digest,
2365                         digest,
2366                         DIGEST_BYTE_LENGTH_SHA512);
2367
2368         /* Generate Crypto op data structure */
2369         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2370                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2371         TEST_ASSERT_NOT_NULL(ut_params->op,
2372                         "Failed to allocate symmetric crypto operation struct");
2373
2374         rte_crypto_op_attach_sym_session(ut_params->op, sess);
2375
2376         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2377
2378         /* set crypto operation source mbuf */
2379         sym_op->m_src = ut_params->ibuf;
2380
2381         sym_op->auth.digest.data = ut_params->digest;
2382         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2383                         ut_params->ibuf, QUOTE_512_BYTES);
2384
2385         sym_op->auth.data.offset = 0;
2386         sym_op->auth.data.length = QUOTE_512_BYTES;
2387
2388         /* Copy IV at the end of the crypto operation */
2389         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2390                         iv, CIPHER_IV_LENGTH_AES_CBC);
2391
2392         sym_op->cipher.data.offset = 0;
2393         sym_op->cipher.data.length = QUOTE_512_BYTES;
2394
2395         /* Process crypto operation */
2396         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
2397                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
2398                         ut_params->op);
2399         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
2400                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
2401                                 ut_params->op, 1, 1, 0, 0);
2402         else
2403                 TEST_ASSERT_NOT_NULL(
2404                                 process_crypto_request(ts_params->valid_devs[0],
2405                                         ut_params->op),
2406                                         "failed to process sym crypto op");
2407
2408         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2409                         "crypto op processing failed");
2410
2411         ut_params->obuf = ut_params->op->sym->m_src;
2412
2413         /* Validate obuf */
2414         TEST_ASSERT_BUFFERS_ARE_EQUAL(
2415                         rte_pktmbuf_mtod(ut_params->obuf, uint8_t *),
2416                         catch_22_quote,
2417                         QUOTE_512_BYTES,
2418                         "Plaintext data not as expected");
2419
2420         /* Validate obuf */
2421         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
2422                         "Digest verification failed");
2423
2424         return TEST_SUCCESS;
2425 }
2426
2427 /* ***** SNOW 3G Tests ***** */
2428 static int
2429 create_wireless_algo_hash_session(uint8_t dev_id,
2430         const uint8_t *key, const uint8_t key_len,
2431         const uint8_t iv_len, const uint8_t auth_len,
2432         enum rte_crypto_auth_operation op,
2433         enum rte_crypto_auth_algorithm algo)
2434 {
2435         uint8_t hash_key[key_len];
2436         int status;
2437
2438         struct crypto_testsuite_params *ts_params = &testsuite_params;
2439         struct crypto_unittest_params *ut_params = &unittest_params;
2440
2441         memcpy(hash_key, key, key_len);
2442
2443         debug_hexdump(stdout, "key:", key, key_len);
2444
2445         /* Setup Authentication Parameters */
2446         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2447         ut_params->auth_xform.next = NULL;
2448
2449         ut_params->auth_xform.auth.op = op;
2450         ut_params->auth_xform.auth.algo = algo;
2451         ut_params->auth_xform.auth.key.length = key_len;
2452         ut_params->auth_xform.auth.key.data = hash_key;
2453         ut_params->auth_xform.auth.digest_length = auth_len;
2454         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
2455         ut_params->auth_xform.auth.iv.length = iv_len;
2456         ut_params->sess = rte_cryptodev_sym_session_create(
2457                         ts_params->session_mpool);
2458
2459         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2460                         &ut_params->auth_xform,
2461                         ts_params->session_priv_mpool);
2462         if (status == -ENOTSUP)
2463                 return TEST_SKIPPED;
2464
2465         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2466         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2467         return 0;
2468 }
2469
2470 static int
2471 create_wireless_algo_cipher_session(uint8_t dev_id,
2472                         enum rte_crypto_cipher_operation op,
2473                         enum rte_crypto_cipher_algorithm algo,
2474                         const uint8_t *key, const uint8_t key_len,
2475                         uint8_t iv_len)
2476 {
2477         uint8_t cipher_key[key_len];
2478         int status;
2479         struct crypto_testsuite_params *ts_params = &testsuite_params;
2480         struct crypto_unittest_params *ut_params = &unittest_params;
2481
2482         memcpy(cipher_key, key, key_len);
2483
2484         /* Setup Cipher Parameters */
2485         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2486         ut_params->cipher_xform.next = NULL;
2487
2488         ut_params->cipher_xform.cipher.algo = algo;
2489         ut_params->cipher_xform.cipher.op = op;
2490         ut_params->cipher_xform.cipher.key.data = cipher_key;
2491         ut_params->cipher_xform.cipher.key.length = key_len;
2492         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2493         ut_params->cipher_xform.cipher.iv.length = iv_len;
2494
2495         debug_hexdump(stdout, "key:", key, key_len);
2496
2497         /* Create Crypto session */
2498         ut_params->sess = rte_cryptodev_sym_session_create(
2499                         ts_params->session_mpool);
2500
2501         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2502                         &ut_params->cipher_xform,
2503                         ts_params->session_priv_mpool);
2504         if (status == -ENOTSUP)
2505                 return TEST_SKIPPED;
2506
2507         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2508         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2509         return 0;
2510 }
2511
2512 static int
2513 create_wireless_algo_cipher_operation(const uint8_t *iv, uint8_t iv_len,
2514                         unsigned int cipher_len,
2515                         unsigned int cipher_offset)
2516 {
2517         struct crypto_testsuite_params *ts_params = &testsuite_params;
2518         struct crypto_unittest_params *ut_params = &unittest_params;
2519
2520         /* Generate Crypto op data structure */
2521         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2522                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2523         TEST_ASSERT_NOT_NULL(ut_params->op,
2524                                 "Failed to allocate pktmbuf offload");
2525
2526         /* Set crypto operation data parameters */
2527         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2528
2529         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2530
2531         /* set crypto operation source mbuf */
2532         sym_op->m_src = ut_params->ibuf;
2533
2534         /* iv */
2535         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2536                         iv, iv_len);
2537         sym_op->cipher.data.length = cipher_len;
2538         sym_op->cipher.data.offset = cipher_offset;
2539         return 0;
2540 }
2541
2542 static int
2543 create_wireless_algo_cipher_operation_oop(const uint8_t *iv, uint8_t iv_len,
2544                         unsigned int cipher_len,
2545                         unsigned int cipher_offset)
2546 {
2547         struct crypto_testsuite_params *ts_params = &testsuite_params;
2548         struct crypto_unittest_params *ut_params = &unittest_params;
2549
2550         /* Generate Crypto op data structure */
2551         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2552                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2553         TEST_ASSERT_NOT_NULL(ut_params->op,
2554                                 "Failed to allocate pktmbuf offload");
2555
2556         /* Set crypto operation data parameters */
2557         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2558
2559         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2560
2561         /* set crypto operation source mbuf */
2562         sym_op->m_src = ut_params->ibuf;
2563         sym_op->m_dst = ut_params->obuf;
2564
2565         /* iv */
2566         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2567                         iv, iv_len);
2568         sym_op->cipher.data.length = cipher_len;
2569         sym_op->cipher.data.offset = cipher_offset;
2570         return 0;
2571 }
2572
2573 static int
2574 create_wireless_algo_cipher_auth_session(uint8_t dev_id,
2575                 enum rte_crypto_cipher_operation cipher_op,
2576                 enum rte_crypto_auth_operation auth_op,
2577                 enum rte_crypto_auth_algorithm auth_algo,
2578                 enum rte_crypto_cipher_algorithm cipher_algo,
2579                 const uint8_t *key, uint8_t key_len,
2580                 uint8_t auth_iv_len, uint8_t auth_len,
2581                 uint8_t cipher_iv_len)
2582
2583 {
2584         uint8_t cipher_auth_key[key_len];
2585         int status;
2586
2587         struct crypto_testsuite_params *ts_params = &testsuite_params;
2588         struct crypto_unittest_params *ut_params = &unittest_params;
2589
2590         memcpy(cipher_auth_key, key, key_len);
2591
2592         /* Setup Authentication Parameters */
2593         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2594         ut_params->auth_xform.next = NULL;
2595
2596         ut_params->auth_xform.auth.op = auth_op;
2597         ut_params->auth_xform.auth.algo = auth_algo;
2598         ut_params->auth_xform.auth.key.length = key_len;
2599         /* Hash key = cipher key */
2600         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2601         ut_params->auth_xform.auth.digest_length = auth_len;
2602         /* Auth IV will be after cipher IV */
2603         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2604         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2605
2606         /* Setup Cipher Parameters */
2607         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2608         ut_params->cipher_xform.next = &ut_params->auth_xform;
2609
2610         ut_params->cipher_xform.cipher.algo = cipher_algo;
2611         ut_params->cipher_xform.cipher.op = cipher_op;
2612         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2613         ut_params->cipher_xform.cipher.key.length = key_len;
2614         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2615         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2616
2617         debug_hexdump(stdout, "key:", key, key_len);
2618
2619         /* Create Crypto session*/
2620         ut_params->sess = rte_cryptodev_sym_session_create(
2621                         ts_params->session_mpool);
2622         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2623
2624         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2625                         &ut_params->cipher_xform,
2626                         ts_params->session_priv_mpool);
2627         if (status == -ENOTSUP)
2628                 return TEST_SKIPPED;
2629
2630         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2631         return 0;
2632 }
2633
2634 static int
2635 create_wireless_cipher_auth_session(uint8_t dev_id,
2636                 enum rte_crypto_cipher_operation cipher_op,
2637                 enum rte_crypto_auth_operation auth_op,
2638                 enum rte_crypto_auth_algorithm auth_algo,
2639                 enum rte_crypto_cipher_algorithm cipher_algo,
2640                 const struct wireless_test_data *tdata)
2641 {
2642         const uint8_t key_len = tdata->key.len;
2643         uint8_t cipher_auth_key[key_len];
2644         int status;
2645
2646         struct crypto_testsuite_params *ts_params = &testsuite_params;
2647         struct crypto_unittest_params *ut_params = &unittest_params;
2648         const uint8_t *key = tdata->key.data;
2649         const uint8_t auth_len = tdata->digest.len;
2650         uint8_t cipher_iv_len = tdata->cipher_iv.len;
2651         uint8_t auth_iv_len = tdata->auth_iv.len;
2652
2653         memcpy(cipher_auth_key, key, key_len);
2654
2655         /* Setup Authentication Parameters */
2656         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2657         ut_params->auth_xform.next = NULL;
2658
2659         ut_params->auth_xform.auth.op = auth_op;
2660         ut_params->auth_xform.auth.algo = auth_algo;
2661         ut_params->auth_xform.auth.key.length = key_len;
2662         /* Hash key = cipher key */
2663         ut_params->auth_xform.auth.key.data = cipher_auth_key;
2664         ut_params->auth_xform.auth.digest_length = auth_len;
2665         /* Auth IV will be after cipher IV */
2666         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2667         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2668
2669         /* Setup Cipher Parameters */
2670         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2671         ut_params->cipher_xform.next = &ut_params->auth_xform;
2672
2673         ut_params->cipher_xform.cipher.algo = cipher_algo;
2674         ut_params->cipher_xform.cipher.op = cipher_op;
2675         ut_params->cipher_xform.cipher.key.data = cipher_auth_key;
2676         ut_params->cipher_xform.cipher.key.length = key_len;
2677         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2678         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2679
2680
2681         debug_hexdump(stdout, "key:", key, key_len);
2682
2683         /* Create Crypto session*/
2684         ut_params->sess = rte_cryptodev_sym_session_create(
2685                         ts_params->session_mpool);
2686
2687         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2688                         &ut_params->cipher_xform,
2689                         ts_params->session_priv_mpool);
2690         if (status == -ENOTSUP)
2691                 return TEST_SKIPPED;
2692
2693         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2694         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2695         return 0;
2696 }
2697
2698 static int
2699 create_zuc_cipher_auth_encrypt_generate_session(uint8_t dev_id,
2700                 const struct wireless_test_data *tdata)
2701 {
2702         return create_wireless_cipher_auth_session(dev_id,
2703                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
2704                 RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3,
2705                 RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata);
2706 }
2707
2708 static int
2709 create_wireless_algo_auth_cipher_session(uint8_t dev_id,
2710                 enum rte_crypto_cipher_operation cipher_op,
2711                 enum rte_crypto_auth_operation auth_op,
2712                 enum rte_crypto_auth_algorithm auth_algo,
2713                 enum rte_crypto_cipher_algorithm cipher_algo,
2714                 const uint8_t *key, const uint8_t key_len,
2715                 uint8_t auth_iv_len, uint8_t auth_len,
2716                 uint8_t cipher_iv_len)
2717 {
2718         uint8_t auth_cipher_key[key_len];
2719         int status;
2720         struct crypto_testsuite_params *ts_params = &testsuite_params;
2721         struct crypto_unittest_params *ut_params = &unittest_params;
2722
2723         memcpy(auth_cipher_key, key, key_len);
2724
2725         /* Setup Authentication Parameters */
2726         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2727         ut_params->auth_xform.auth.op = auth_op;
2728         ut_params->auth_xform.next = &ut_params->cipher_xform;
2729         ut_params->auth_xform.auth.algo = auth_algo;
2730         ut_params->auth_xform.auth.key.length = key_len;
2731         ut_params->auth_xform.auth.key.data = auth_cipher_key;
2732         ut_params->auth_xform.auth.digest_length = auth_len;
2733         /* Auth IV will be after cipher IV */
2734         ut_params->auth_xform.auth.iv.offset = IV_OFFSET + cipher_iv_len;
2735         ut_params->auth_xform.auth.iv.length = auth_iv_len;
2736
2737         /* Setup Cipher Parameters */
2738         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2739         ut_params->cipher_xform.next = NULL;
2740         ut_params->cipher_xform.cipher.algo = cipher_algo;
2741         ut_params->cipher_xform.cipher.op = cipher_op;
2742         ut_params->cipher_xform.cipher.key.data = auth_cipher_key;
2743         ut_params->cipher_xform.cipher.key.length = key_len;
2744         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
2745         ut_params->cipher_xform.cipher.iv.length = cipher_iv_len;
2746
2747         debug_hexdump(stdout, "key:", key, key_len);
2748
2749         /* Create Crypto session*/
2750         ut_params->sess = rte_cryptodev_sym_session_create(
2751                         ts_params->session_mpool);
2752         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2753
2754         if (cipher_op == RTE_CRYPTO_CIPHER_OP_DECRYPT) {
2755                 ut_params->auth_xform.next = NULL;
2756                 ut_params->cipher_xform.next = &ut_params->auth_xform;
2757                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2758                                 &ut_params->cipher_xform,
2759                                 ts_params->session_priv_mpool);
2760
2761         } else
2762                 status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
2763                                 &ut_params->auth_xform,
2764                                 ts_params->session_priv_mpool);
2765
2766         if (status == -ENOTSUP)
2767                 return TEST_SKIPPED;
2768
2769         TEST_ASSERT_EQUAL(status, 0, "session init failed");
2770
2771         return 0;
2772 }
2773
2774 static int
2775 create_wireless_algo_hash_operation(const uint8_t *auth_tag,
2776                 unsigned int auth_tag_len,
2777                 const uint8_t *iv, unsigned int iv_len,
2778                 unsigned int data_pad_len,
2779                 enum rte_crypto_auth_operation op,
2780                 unsigned int auth_len, unsigned int auth_offset)
2781 {
2782         struct crypto_testsuite_params *ts_params = &testsuite_params;
2783
2784         struct crypto_unittest_params *ut_params = &unittest_params;
2785
2786         /* Generate Crypto op data structure */
2787         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2788                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2789         TEST_ASSERT_NOT_NULL(ut_params->op,
2790                 "Failed to allocate pktmbuf offload");
2791
2792         /* Set crypto operation data parameters */
2793         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2794
2795         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2796
2797         /* set crypto operation source mbuf */
2798         sym_op->m_src = ut_params->ibuf;
2799
2800         /* iv */
2801         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
2802                         iv, iv_len);
2803         /* digest */
2804         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2805                                         ut_params->ibuf, auth_tag_len);
2806
2807         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2808                                 "no room to append auth tag");
2809         ut_params->digest = sym_op->auth.digest.data;
2810         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2811                         ut_params->ibuf, data_pad_len);
2812         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2813                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2814         else
2815                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2816
2817         debug_hexdump(stdout, "digest:",
2818                 sym_op->auth.digest.data,
2819                 auth_tag_len);
2820
2821         sym_op->auth.data.length = auth_len;
2822         sym_op->auth.data.offset = auth_offset;
2823
2824         return 0;
2825 }
2826
2827 static int
2828 create_wireless_cipher_hash_operation(const struct wireless_test_data *tdata,
2829         enum rte_crypto_auth_operation op)
2830 {
2831         struct crypto_testsuite_params *ts_params = &testsuite_params;
2832         struct crypto_unittest_params *ut_params = &unittest_params;
2833
2834         const uint8_t *auth_tag = tdata->digest.data;
2835         const unsigned int auth_tag_len = tdata->digest.len;
2836         unsigned int plaintext_len = ceil_byte_length(tdata->plaintext.len);
2837         unsigned int data_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
2838
2839         const uint8_t *cipher_iv = tdata->cipher_iv.data;
2840         const uint8_t cipher_iv_len = tdata->cipher_iv.len;
2841         const uint8_t *auth_iv = tdata->auth_iv.data;
2842         const uint8_t auth_iv_len = tdata->auth_iv.len;
2843         const unsigned int cipher_len = tdata->validCipherLenInBits.len;
2844         const unsigned int auth_len = tdata->validAuthLenInBits.len;
2845
2846         /* Generate Crypto op data structure */
2847         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2848                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2849         TEST_ASSERT_NOT_NULL(ut_params->op,
2850                         "Failed to allocate pktmbuf offload");
2851         /* Set crypto operation data parameters */
2852         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2853
2854         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2855
2856         /* set crypto operation source mbuf */
2857         sym_op->m_src = ut_params->ibuf;
2858
2859         /* digest */
2860         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2861                         ut_params->ibuf, auth_tag_len);
2862
2863         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2864                         "no room to append auth tag");
2865         ut_params->digest = sym_op->auth.digest.data;
2866         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2867                         ut_params->ibuf, data_pad_len);
2868         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2869                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2870         else
2871                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2872
2873         debug_hexdump(stdout, "digest:",
2874                 sym_op->auth.digest.data,
2875                 auth_tag_len);
2876
2877         /* Copy cipher and auth IVs at the end of the crypto operation */
2878         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2879                                                 IV_OFFSET);
2880         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2881         iv_ptr += cipher_iv_len;
2882         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2883
2884         sym_op->cipher.data.length = cipher_len;
2885         sym_op->cipher.data.offset = 0;
2886         sym_op->auth.data.length = auth_len;
2887         sym_op->auth.data.offset = 0;
2888
2889         return 0;
2890 }
2891
2892 static int
2893 create_zuc_cipher_hash_generate_operation(
2894                 const struct wireless_test_data *tdata)
2895 {
2896         return create_wireless_cipher_hash_operation(tdata,
2897                 RTE_CRYPTO_AUTH_OP_GENERATE);
2898 }
2899
2900 static int
2901 create_wireless_algo_cipher_hash_operation(const uint8_t *auth_tag,
2902                 const unsigned auth_tag_len,
2903                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2904                 unsigned data_pad_len,
2905                 enum rte_crypto_auth_operation op,
2906                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2907                 const unsigned cipher_len, const unsigned cipher_offset,
2908                 const unsigned auth_len, const unsigned auth_offset)
2909 {
2910         struct crypto_testsuite_params *ts_params = &testsuite_params;
2911         struct crypto_unittest_params *ut_params = &unittest_params;
2912
2913         enum rte_crypto_cipher_algorithm cipher_algo =
2914                         ut_params->cipher_xform.cipher.algo;
2915         enum rte_crypto_auth_algorithm auth_algo =
2916                         ut_params->auth_xform.auth.algo;
2917
2918         /* Generate Crypto op data structure */
2919         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
2920                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2921         TEST_ASSERT_NOT_NULL(ut_params->op,
2922                         "Failed to allocate pktmbuf offload");
2923         /* Set crypto operation data parameters */
2924         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
2925
2926         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
2927
2928         /* set crypto operation source mbuf */
2929         sym_op->m_src = ut_params->ibuf;
2930
2931         /* digest */
2932         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
2933                         ut_params->ibuf, auth_tag_len);
2934
2935         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
2936                         "no room to append auth tag");
2937         ut_params->digest = sym_op->auth.digest.data;
2938
2939         if (rte_pktmbuf_is_contiguous(ut_params->ibuf)) {
2940                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2941                                 ut_params->ibuf, data_pad_len);
2942         } else {
2943                 struct rte_mbuf *m = ut_params->ibuf;
2944                 unsigned int offset = data_pad_len;
2945
2946                 while (offset > m->data_len && m->next != NULL) {
2947                         offset -= m->data_len;
2948                         m = m->next;
2949                 }
2950                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
2951                         m, offset);
2952         }
2953
2954         if (op == RTE_CRYPTO_AUTH_OP_GENERATE)
2955                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
2956         else
2957                 rte_memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
2958
2959         debug_hexdump(stdout, "digest:",
2960                 sym_op->auth.digest.data,
2961                 auth_tag_len);
2962
2963         /* Copy cipher and auth IVs at the end of the crypto operation */
2964         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, uint8_t *,
2965                                                 IV_OFFSET);
2966         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
2967         iv_ptr += cipher_iv_len;
2968         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
2969
2970         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
2971                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
2972                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
2973                 sym_op->cipher.data.length = cipher_len;
2974                 sym_op->cipher.data.offset = cipher_offset;
2975         } else {
2976                 sym_op->cipher.data.length = cipher_len >> 3;
2977                 sym_op->cipher.data.offset = cipher_offset >> 3;
2978         }
2979
2980         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
2981                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
2982                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
2983                 sym_op->auth.data.length = auth_len;
2984                 sym_op->auth.data.offset = auth_offset;
2985         } else {
2986                 sym_op->auth.data.length = auth_len >> 3;
2987                 sym_op->auth.data.offset = auth_offset >> 3;
2988         }
2989
2990         return 0;
2991 }
2992
2993 static int
2994 create_wireless_algo_auth_cipher_operation(
2995                 const uint8_t *auth_tag, unsigned int auth_tag_len,
2996                 const uint8_t *cipher_iv, uint8_t cipher_iv_len,
2997                 const uint8_t *auth_iv, uint8_t auth_iv_len,
2998                 unsigned int data_pad_len,
2999                 unsigned int cipher_len, unsigned int cipher_offset,
3000                 unsigned int auth_len, unsigned int auth_offset,
3001                 uint8_t op_mode, uint8_t do_sgl, uint8_t verify)
3002 {
3003         struct crypto_testsuite_params *ts_params = &testsuite_params;
3004         struct crypto_unittest_params *ut_params = &unittest_params;
3005
3006         enum rte_crypto_cipher_algorithm cipher_algo =
3007                         ut_params->cipher_xform.cipher.algo;
3008         enum rte_crypto_auth_algorithm auth_algo =
3009                         ut_params->auth_xform.auth.algo;
3010
3011         /* Generate Crypto op data structure */
3012         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
3013                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
3014         TEST_ASSERT_NOT_NULL(ut_params->op,
3015                         "Failed to allocate pktmbuf offload");
3016
3017         /* Set crypto operation data parameters */
3018         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
3019
3020         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
3021
3022         /* set crypto operation mbufs */
3023         sym_op->m_src = ut_params->ibuf;
3024         if (op_mode == OUT_OF_PLACE)
3025                 sym_op->m_dst = ut_params->obuf;
3026
3027         /* digest */
3028         if (!do_sgl) {
3029                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(
3030                         (op_mode == IN_PLACE ?
3031                                 ut_params->ibuf : ut_params->obuf),
3032                         uint8_t *, data_pad_len);
3033                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
3034                         (op_mode == IN_PLACE ?
3035                                 ut_params->ibuf : ut_params->obuf),
3036                         data_pad_len);
3037                 memset(sym_op->auth.digest.data, 0, auth_tag_len);
3038         } else {
3039                 uint16_t remaining_off = (auth_offset >> 3) + (auth_len >> 3);
3040                 struct rte_mbuf *sgl_buf = (op_mode == IN_PLACE ?
3041                                 sym_op->m_src : sym_op->m_dst);
3042                 while (remaining_off >= rte_pktmbuf_data_len(sgl_buf)) {
3043                         remaining_off -= rte_pktmbuf_data_len(sgl_buf);
3044                         sgl_buf = sgl_buf->next;
3045                 }
3046                 sym_op->auth.digest.data = rte_pktmbuf_mtod_offset(sgl_buf,
3047                                 uint8_t *, remaining_off);
3048                 sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(sgl_buf,
3049                                 remaining_off);
3050                 memset(sym_op->auth.digest.data, 0, remaining_off);
3051                 while (sgl_buf->next != NULL) {
3052                         memset(rte_pktmbuf_mtod(sgl_buf, uint8_t *),
3053                                 0, rte_pktmbuf_data_len(sgl_buf));
3054                         sgl_buf = sgl_buf->next;
3055                 }
3056         }
3057
3058         /* Copy digest for the verification */
3059         if (verify)
3060                 memcpy(sym_op->auth.digest.data, auth_tag, auth_tag_len);
3061
3062         /* Copy cipher and auth IVs at the end of the crypto operation */
3063         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(
3064                         ut_params->op, uint8_t *, IV_OFFSET);
3065
3066         rte_memcpy(iv_ptr, cipher_iv, cipher_iv_len);
3067         iv_ptr += cipher_iv_len;
3068         rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
3069
3070         /* Only copy over the offset data needed from src to dst in OOP,
3071          * if the auth and cipher offsets are not aligned
3072          */
3073         if (op_mode == OUT_OF_PLACE) {
3074                 if (cipher_offset > auth_offset)
3075                         rte_memcpy(
3076                                 rte_pktmbuf_mtod_offset(
3077                                         sym_op->m_dst,
3078                                         uint8_t *, auth_offset >> 3),
3079                                 rte_pktmbuf_mtod_offset(
3080                                         sym_op->m_src,
3081                                         uint8_t *, auth_offset >> 3),
3082                                 ((cipher_offset >> 3) - (auth_offset >> 3)));
3083         }
3084
3085         if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
3086                 cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
3087                 cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
3088                 sym_op->cipher.data.length = cipher_len;
3089                 sym_op->cipher.data.offset = cipher_offset;
3090         } else {
3091                 sym_op->cipher.data.length = cipher_len >> 3;
3092                 sym_op->cipher.data.offset = cipher_offset >> 3;
3093         }
3094
3095         if (auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 ||
3096                 auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9 ||
3097                 auth_algo == RTE_CRYPTO_AUTH_ZUC_EIA3) {
3098                 sym_op->auth.data.length = auth_len;
3099                 sym_op->auth.data.offset = auth_offset;
3100         } else {
3101                 sym_op->auth.data.length = auth_len >> 3;
3102                 sym_op->auth.data.offset = auth_offset >> 3;
3103         }
3104
3105         return 0;
3106 }
3107
3108 static int
3109 test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
3110 {
3111         struct crypto_testsuite_params *ts_params = &testsuite_params;
3112         struct crypto_unittest_params *ut_params = &unittest_params;
3113
3114         int retval;
3115         unsigned plaintext_pad_len;
3116         unsigned plaintext_len;
3117         uint8_t *plaintext;
3118         struct rte_cryptodev_info dev_info;
3119
3120         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3121         uint64_t feat_flags = dev_info.feature_flags;
3122
3123         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3124                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3125                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3126                 return TEST_SKIPPED;
3127         }
3128
3129         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3130                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3131                 printf("Device doesn't support RAW data-path APIs.\n");
3132                 return TEST_SKIPPED;
3133         }
3134
3135         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3136                 return TEST_SKIPPED;
3137
3138         /* Verify the capabilities */
3139         struct rte_cryptodev_sym_capability_idx cap_idx;
3140         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3141         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3142         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3143                         &cap_idx) == NULL)
3144                 return TEST_SKIPPED;
3145
3146         /* Create SNOW 3G session */
3147         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3148                         tdata->key.data, tdata->key.len,
3149                         tdata->auth_iv.len, tdata->digest.len,
3150                         RTE_CRYPTO_AUTH_OP_GENERATE,
3151                         RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3152         if (retval < 0)
3153                 return retval;
3154
3155         /* alloc mbuf and set payload */
3156         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3157
3158         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3159         rte_pktmbuf_tailroom(ut_params->ibuf));
3160
3161         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3162         /* Append data which is padded to a multiple of */
3163         /* the algorithms block size */
3164         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3165         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3166                                 plaintext_pad_len);
3167         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3168
3169         /* Create SNOW 3G operation */
3170         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3171                         tdata->auth_iv.data, tdata->auth_iv.len,
3172                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3173                         tdata->validAuthLenInBits.len,
3174                         0);
3175         if (retval < 0)
3176                 return retval;
3177
3178         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3179                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3180                                 ut_params->op, 0, 1, 1, 0);
3181         else
3182                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3183                                 ut_params->op);
3184         ut_params->obuf = ut_params->op->sym->m_src;
3185         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3186         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3187                         + plaintext_pad_len;
3188
3189         /* Validate obuf */
3190         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3191         ut_params->digest,
3192         tdata->digest.data,
3193         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
3194         "SNOW 3G Generated auth tag not as expected");
3195
3196         return 0;
3197 }
3198
3199 static int
3200 test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
3201 {
3202         struct crypto_testsuite_params *ts_params = &testsuite_params;
3203         struct crypto_unittest_params *ut_params = &unittest_params;
3204
3205         int retval;
3206         unsigned plaintext_pad_len;
3207         unsigned plaintext_len;
3208         uint8_t *plaintext;
3209         struct rte_cryptodev_info dev_info;
3210
3211         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3212         uint64_t feat_flags = dev_info.feature_flags;
3213
3214         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
3215                         ((tdata->validAuthLenInBits.len % 8) != 0)) {
3216                 printf("Device doesn't support NON-Byte Aligned Data.\n");
3217                 return TEST_SKIPPED;
3218         }
3219
3220         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3221                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3222                 printf("Device doesn't support RAW data-path APIs.\n");
3223                 return TEST_SKIPPED;
3224         }
3225
3226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3227                 return TEST_SKIPPED;
3228
3229         /* Verify the capabilities */
3230         struct rte_cryptodev_sym_capability_idx cap_idx;
3231         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3232         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
3233         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3234                         &cap_idx) == NULL)
3235                 return TEST_SKIPPED;
3236
3237         /* Create SNOW 3G session */
3238         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3239                                 tdata->key.data, tdata->key.len,
3240                                 tdata->auth_iv.len, tdata->digest.len,
3241                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3242                                 RTE_CRYPTO_AUTH_SNOW3G_UIA2);
3243         if (retval < 0)
3244                 return retval;
3245         /* alloc mbuf and set payload */
3246         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3247
3248         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3249         rte_pktmbuf_tailroom(ut_params->ibuf));
3250
3251         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3252         /* Append data which is padded to a multiple of */
3253         /* the algorithms block size */
3254         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
3255         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3256                                 plaintext_pad_len);
3257         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3258
3259         /* Create SNOW 3G operation */
3260         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3261                         tdata->digest.len,
3262                         tdata->auth_iv.data, tdata->auth_iv.len,
3263                         plaintext_pad_len,
3264                         RTE_CRYPTO_AUTH_OP_VERIFY,
3265                         tdata->validAuthLenInBits.len,
3266                         0);
3267         if (retval < 0)
3268                 return retval;
3269
3270         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3271                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3272                                 ut_params->op, 0, 1, 1, 0);
3273         else
3274                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3275                                 ut_params->op);
3276         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3277         ut_params->obuf = ut_params->op->sym->m_src;
3278         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3279                                 + plaintext_pad_len;
3280
3281         /* Validate obuf */
3282         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3283                 return 0;
3284         else
3285                 return -1;
3286
3287         return 0;
3288 }
3289
3290 static int
3291 test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
3292 {
3293         struct crypto_testsuite_params *ts_params = &testsuite_params;
3294         struct crypto_unittest_params *ut_params = &unittest_params;
3295
3296         int retval;
3297         unsigned plaintext_pad_len;
3298         unsigned plaintext_len;
3299         uint8_t *plaintext;
3300         struct rte_cryptodev_info dev_info;
3301
3302         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3303         uint64_t feat_flags = dev_info.feature_flags;
3304
3305         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3306                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3307                 printf("Device doesn't support RAW data-path APIs.\n");
3308                 return TEST_SKIPPED;
3309         }
3310
3311         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3312                 return TEST_SKIPPED;
3313
3314         /* Verify the capabilities */
3315         struct rte_cryptodev_sym_capability_idx cap_idx;
3316         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3317         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3318         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3319                         &cap_idx) == NULL)
3320                 return TEST_SKIPPED;
3321
3322         /* Create KASUMI session */
3323         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3324                         tdata->key.data, tdata->key.len,
3325                         0, tdata->digest.len,
3326                         RTE_CRYPTO_AUTH_OP_GENERATE,
3327                         RTE_CRYPTO_AUTH_KASUMI_F9);
3328         if (retval < 0)
3329                 return retval;
3330
3331         /* alloc mbuf and set payload */
3332         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3333
3334         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3335         rte_pktmbuf_tailroom(ut_params->ibuf));
3336
3337         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3338         /* Append data which is padded to a multiple of */
3339         /* the algorithms block size */
3340         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3341         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3342                                 plaintext_pad_len);
3343         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3344
3345         /* Create KASUMI operation */
3346         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
3347                         NULL, 0,
3348                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
3349                         tdata->plaintext.len,
3350                         0);
3351         if (retval < 0)
3352                 return retval;
3353
3354         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3355                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
3356                         ut_params->op);
3357         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3358                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3359                                 ut_params->op, 0, 1, 1, 0);
3360         else
3361                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3362                         ut_params->op);
3363
3364         ut_params->obuf = ut_params->op->sym->m_src;
3365         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3366         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3367                         + plaintext_pad_len;
3368
3369         /* Validate obuf */
3370         TEST_ASSERT_BUFFERS_ARE_EQUAL(
3371         ut_params->digest,
3372         tdata->digest.data,
3373         DIGEST_BYTE_LENGTH_KASUMI_F9,
3374         "KASUMI Generated auth tag not as expected");
3375
3376         return 0;
3377 }
3378
3379 static int
3380 test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
3381 {
3382         struct crypto_testsuite_params *ts_params = &testsuite_params;
3383         struct crypto_unittest_params *ut_params = &unittest_params;
3384
3385         int retval;
3386         unsigned plaintext_pad_len;
3387         unsigned plaintext_len;
3388         uint8_t *plaintext;
3389         struct rte_cryptodev_info dev_info;
3390
3391         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3392         uint64_t feat_flags = dev_info.feature_flags;
3393
3394         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3395                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3396                 printf("Device doesn't support RAW data-path APIs.\n");
3397                 return TEST_SKIPPED;
3398         }
3399
3400         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3401                 return TEST_SKIPPED;
3402
3403         /* Verify the capabilities */
3404         struct rte_cryptodev_sym_capability_idx cap_idx;
3405         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3406         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
3407         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3408                         &cap_idx) == NULL)
3409                 return TEST_SKIPPED;
3410
3411         /* Create KASUMI session */
3412         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
3413                                 tdata->key.data, tdata->key.len,
3414                                 0, tdata->digest.len,
3415                                 RTE_CRYPTO_AUTH_OP_VERIFY,
3416                                 RTE_CRYPTO_AUTH_KASUMI_F9);
3417         if (retval < 0)
3418                 return retval;
3419         /* alloc mbuf and set payload */
3420         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3421
3422         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3423         rte_pktmbuf_tailroom(ut_params->ibuf));
3424
3425         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3426         /* Append data which is padded to a multiple */
3427         /* of the algorithms block size */
3428         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3429         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3430                                 plaintext_pad_len);
3431         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3432
3433         /* Create KASUMI operation */
3434         retval = create_wireless_algo_hash_operation(tdata->digest.data,
3435                         tdata->digest.len,
3436                         NULL, 0,
3437                         plaintext_pad_len,
3438                         RTE_CRYPTO_AUTH_OP_VERIFY,
3439                         tdata->plaintext.len,
3440                         0);
3441         if (retval < 0)
3442                 return retval;
3443
3444         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3445                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3446                                 ut_params->op, 0, 1, 1, 0);
3447         else
3448                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3449                                 ut_params->op);
3450         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3451         ut_params->obuf = ut_params->op->sym->m_src;
3452         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
3453                                 + plaintext_pad_len;
3454
3455         /* Validate obuf */
3456         if (ut_params->op->status == RTE_CRYPTO_OP_STATUS_SUCCESS)
3457                 return 0;
3458         else
3459                 return -1;
3460
3461         return 0;
3462 }
3463
3464 static int
3465 test_snow3g_hash_generate_test_case_1(void)
3466 {
3467         return test_snow3g_authentication(&snow3g_hash_test_case_1);
3468 }
3469
3470 static int
3471 test_snow3g_hash_generate_test_case_2(void)
3472 {
3473         return test_snow3g_authentication(&snow3g_hash_test_case_2);
3474 }
3475
3476 static int
3477 test_snow3g_hash_generate_test_case_3(void)
3478 {
3479         return test_snow3g_authentication(&snow3g_hash_test_case_3);
3480 }
3481
3482 static int
3483 test_snow3g_hash_generate_test_case_4(void)
3484 {
3485         return test_snow3g_authentication(&snow3g_hash_test_case_4);
3486 }
3487
3488 static int
3489 test_snow3g_hash_generate_test_case_5(void)
3490 {
3491         return test_snow3g_authentication(&snow3g_hash_test_case_5);
3492 }
3493
3494 static int
3495 test_snow3g_hash_generate_test_case_6(void)
3496 {
3497         return test_snow3g_authentication(&snow3g_hash_test_case_6);
3498 }
3499
3500 static int
3501 test_snow3g_hash_verify_test_case_1(void)
3502 {
3503         return test_snow3g_authentication_verify(&snow3g_hash_test_case_1);
3504
3505 }
3506
3507 static int
3508 test_snow3g_hash_verify_test_case_2(void)
3509 {
3510         return test_snow3g_authentication_verify(&snow3g_hash_test_case_2);
3511 }
3512
3513 static int
3514 test_snow3g_hash_verify_test_case_3(void)
3515 {
3516         return test_snow3g_authentication_verify(&snow3g_hash_test_case_3);
3517 }
3518
3519 static int
3520 test_snow3g_hash_verify_test_case_4(void)
3521 {
3522         return test_snow3g_authentication_verify(&snow3g_hash_test_case_4);
3523 }
3524
3525 static int
3526 test_snow3g_hash_verify_test_case_5(void)
3527 {
3528         return test_snow3g_authentication_verify(&snow3g_hash_test_case_5);
3529 }
3530
3531 static int
3532 test_snow3g_hash_verify_test_case_6(void)
3533 {
3534         return test_snow3g_authentication_verify(&snow3g_hash_test_case_6);
3535 }
3536
3537 static int
3538 test_kasumi_hash_generate_test_case_1(void)
3539 {
3540         return test_kasumi_authentication(&kasumi_hash_test_case_1);
3541 }
3542
3543 static int
3544 test_kasumi_hash_generate_test_case_2(void)
3545 {
3546         return test_kasumi_authentication(&kasumi_hash_test_case_2);
3547 }
3548
3549 static int
3550 test_kasumi_hash_generate_test_case_3(void)
3551 {
3552         return test_kasumi_authentication(&kasumi_hash_test_case_3);
3553 }
3554
3555 static int
3556 test_kasumi_hash_generate_test_case_4(void)
3557 {
3558         return test_kasumi_authentication(&kasumi_hash_test_case_4);
3559 }
3560
3561 static int
3562 test_kasumi_hash_generate_test_case_5(void)
3563 {
3564         return test_kasumi_authentication(&kasumi_hash_test_case_5);
3565 }
3566
3567 static int
3568 test_kasumi_hash_generate_test_case_6(void)
3569 {
3570         return test_kasumi_authentication(&kasumi_hash_test_case_6);
3571 }
3572
3573 static int
3574 test_kasumi_hash_verify_test_case_1(void)
3575 {
3576         return test_kasumi_authentication_verify(&kasumi_hash_test_case_1);
3577 }
3578
3579 static int
3580 test_kasumi_hash_verify_test_case_2(void)
3581 {
3582         return test_kasumi_authentication_verify(&kasumi_hash_test_case_2);
3583 }
3584
3585 static int
3586 test_kasumi_hash_verify_test_case_3(void)
3587 {
3588         return test_kasumi_authentication_verify(&kasumi_hash_test_case_3);
3589 }
3590
3591 static int
3592 test_kasumi_hash_verify_test_case_4(void)
3593 {
3594         return test_kasumi_authentication_verify(&kasumi_hash_test_case_4);
3595 }
3596
3597 static int
3598 test_kasumi_hash_verify_test_case_5(void)
3599 {
3600         return test_kasumi_authentication_verify(&kasumi_hash_test_case_5);
3601 }
3602
3603 static int
3604 test_kasumi_encryption(const struct kasumi_test_data *tdata)
3605 {
3606         struct crypto_testsuite_params *ts_params = &testsuite_params;
3607         struct crypto_unittest_params *ut_params = &unittest_params;
3608
3609         int retval;
3610         uint8_t *plaintext, *ciphertext;
3611         unsigned plaintext_pad_len;
3612         unsigned plaintext_len;
3613         struct rte_cryptodev_info dev_info;
3614
3615         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3616         uint64_t feat_flags = dev_info.feature_flags;
3617
3618         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3619                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3620                 printf("Device doesn't support RAW data-path APIs.\n");
3621                 return TEST_SKIPPED;
3622         }
3623
3624         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3625                 return TEST_SKIPPED;
3626
3627         /* Verify the capabilities */
3628         struct rte_cryptodev_sym_capability_idx cap_idx;
3629         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3630         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3631         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3632                         &cap_idx) == NULL)
3633                 return TEST_SKIPPED;
3634
3635         /* Create KASUMI session */
3636         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3637                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3638                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3639                                         tdata->key.data, tdata->key.len,
3640                                         tdata->cipher_iv.len);
3641         if (retval < 0)
3642                 return retval;
3643
3644         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3645
3646         /* Clear mbuf payload */
3647         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3648                rte_pktmbuf_tailroom(ut_params->ibuf));
3649
3650         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3651         /* Append data which is padded to a multiple */
3652         /* of the algorithms block size */
3653         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3654         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3655                                 plaintext_pad_len);
3656         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3657
3658         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3659
3660         /* Create KASUMI operation */
3661         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3662                                 tdata->cipher_iv.len,
3663                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3664                                 tdata->validCipherOffsetInBits.len);
3665         if (retval < 0)
3666                 return retval;
3667
3668         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3669                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3670                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3671         else
3672                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3673                                 ut_params->op);
3674         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3675
3676         ut_params->obuf = ut_params->op->sym->m_dst;
3677         if (ut_params->obuf)
3678                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3679         else
3680                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3681
3682         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3683
3684         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3685                                 (tdata->validCipherOffsetInBits.len >> 3);
3686         /* Validate obuf */
3687         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3688                 ciphertext,
3689                 reference_ciphertext,
3690                 tdata->validCipherLenInBits.len,
3691                 "KASUMI Ciphertext data not as expected");
3692         return 0;
3693 }
3694
3695 static int
3696 test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
3697 {
3698         struct crypto_testsuite_params *ts_params = &testsuite_params;
3699         struct crypto_unittest_params *ut_params = &unittest_params;
3700
3701         int retval;
3702
3703         unsigned int plaintext_pad_len;
3704         unsigned int plaintext_len;
3705
3706         uint8_t buffer[10000];
3707         const uint8_t *ciphertext;
3708
3709         struct rte_cryptodev_info dev_info;
3710
3711         /* Verify the capabilities */
3712         struct rte_cryptodev_sym_capability_idx cap_idx;
3713         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3714         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3715         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3716                         &cap_idx) == NULL)
3717                 return TEST_SKIPPED;
3718
3719         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3720
3721         uint64_t feat_flags = dev_info.feature_flags;
3722
3723         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
3724                 printf("Device doesn't support in-place scatter-gather. "
3725                                 "Test Skipped.\n");
3726                 return TEST_SKIPPED;
3727         }
3728
3729         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
3730                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
3731                 printf("Device doesn't support RAW data-path APIs.\n");
3732                 return TEST_SKIPPED;
3733         }
3734
3735         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3736                 return TEST_SKIPPED;
3737
3738         /* Create KASUMI session */
3739         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3740                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3741                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3742                                         tdata->key.data, tdata->key.len,
3743                                         tdata->cipher_iv.len);
3744         if (retval < 0)
3745                 return retval;
3746
3747         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3748
3749
3750         /* Append data which is padded to a multiple */
3751         /* of the algorithms block size */
3752         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3753
3754         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3755                         plaintext_pad_len, 10, 0);
3756
3757         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3758
3759         /* Create KASUMI operation */
3760         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
3761                                 tdata->cipher_iv.len,
3762                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3763                                 tdata->validCipherOffsetInBits.len);
3764         if (retval < 0)
3765                 return retval;
3766
3767         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3768                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
3769                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
3770         else
3771                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3772                                                 ut_params->op);
3773         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3774
3775         ut_params->obuf = ut_params->op->sym->m_dst;
3776
3777         if (ut_params->obuf)
3778                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3779                                 plaintext_len, buffer);
3780         else
3781                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3782                                 tdata->validCipherOffsetInBits.len >> 3,
3783                                 plaintext_len, buffer);
3784
3785         /* Validate obuf */
3786         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3787
3788         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3789                                 (tdata->validCipherOffsetInBits.len >> 3);
3790         /* Validate obuf */
3791         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3792                 ciphertext,
3793                 reference_ciphertext,
3794                 tdata->validCipherLenInBits.len,
3795                 "KASUMI Ciphertext data not as expected");
3796         return 0;
3797 }
3798
3799 static int
3800 test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
3801 {
3802         struct crypto_testsuite_params *ts_params = &testsuite_params;
3803         struct crypto_unittest_params *ut_params = &unittest_params;
3804
3805         int retval;
3806         uint8_t *plaintext, *ciphertext;
3807         unsigned plaintext_pad_len;
3808         unsigned plaintext_len;
3809
3810         /* Verify the capabilities */
3811         struct rte_cryptodev_sym_capability_idx cap_idx;
3812         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3813         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3814         /* Data-path service does not support OOP */
3815         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3816                         &cap_idx) == NULL)
3817                 return TEST_SKIPPED;
3818
3819         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3820                 return TEST_SKIPPED;
3821
3822         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3823                 return TEST_SKIPPED;
3824
3825         /* Create KASUMI session */
3826         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3827                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3828                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3829                                         tdata->key.data, tdata->key.len,
3830                                         tdata->cipher_iv.len);
3831         if (retval < 0)
3832                 return retval;
3833
3834         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3835         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
3836
3837         /* Clear mbuf payload */
3838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
3839                rte_pktmbuf_tailroom(ut_params->ibuf));
3840
3841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3842         /* Append data which is padded to a multiple */
3843         /* of the algorithms block size */
3844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
3846                                 plaintext_pad_len);
3847         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
3848         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
3849
3850         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
3851
3852         /* Create KASUMI operation */
3853         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3854                                 tdata->cipher_iv.len,
3855                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3856                                 tdata->validCipherOffsetInBits.len);
3857         if (retval < 0)
3858                 return retval;
3859
3860         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3861                                                 ut_params->op);
3862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3863
3864         ut_params->obuf = ut_params->op->sym->m_dst;
3865         if (ut_params->obuf)
3866                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
3867         else
3868                 ciphertext = plaintext + (tdata->validCipherOffsetInBits.len >> 3);
3869
3870         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
3871
3872         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3873                                 (tdata->validCipherOffsetInBits.len >> 3);
3874         /* Validate obuf */
3875         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3876                 ciphertext,
3877                 reference_ciphertext,
3878                 tdata->validCipherLenInBits.len,
3879                 "KASUMI Ciphertext data not as expected");
3880         return 0;
3881 }
3882
3883 static int
3884 test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
3885 {
3886         struct crypto_testsuite_params *ts_params = &testsuite_params;
3887         struct crypto_unittest_params *ut_params = &unittest_params;
3888
3889         int retval;
3890         unsigned int plaintext_pad_len;
3891         unsigned int plaintext_len;
3892
3893         const uint8_t *ciphertext;
3894         uint8_t buffer[2048];
3895
3896         struct rte_cryptodev_info dev_info;
3897
3898         /* Verify the capabilities */
3899         struct rte_cryptodev_sym_capability_idx cap_idx;
3900         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3901         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3902         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3903                         &cap_idx) == NULL)
3904                 return TEST_SKIPPED;
3905
3906         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3907                 return TEST_SKIPPED;
3908
3909         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
3910                 return TEST_SKIPPED;
3911
3912         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
3913
3914         uint64_t feat_flags = dev_info.feature_flags;
3915         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
3916                 printf("Device doesn't support out-of-place scatter-gather "
3917                                 "in both input and output mbufs. "
3918                                 "Test Skipped.\n");
3919                 return TEST_SKIPPED;
3920         }
3921
3922         /* Create KASUMI session */
3923         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
3924                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
3925                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
3926                                         tdata->key.data, tdata->key.len,
3927                                         tdata->cipher_iv.len);
3928         if (retval < 0)
3929                 return retval;
3930
3931         plaintext_len = ceil_byte_length(tdata->plaintext.len);
3932         /* Append data which is padded to a multiple */
3933         /* of the algorithms block size */
3934         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
3935
3936         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
3937                         plaintext_pad_len, 10, 0);
3938         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
3939                         plaintext_pad_len, 3, 0);
3940
3941         /* Append data which is padded to a multiple */
3942         /* of the algorithms block size */
3943         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
3944
3945         /* Create KASUMI operation */
3946         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
3947                                 tdata->cipher_iv.len,
3948                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
3949                                 tdata->validCipherOffsetInBits.len);
3950         if (retval < 0)
3951                 return retval;
3952
3953         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
3954                                                 ut_params->op);
3955         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
3956
3957         ut_params->obuf = ut_params->op->sym->m_dst;
3958         if (ut_params->obuf)
3959                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
3960                                 plaintext_pad_len, buffer);
3961         else
3962                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
3963                                 tdata->validCipherOffsetInBits.len >> 3,
3964                                 plaintext_pad_len, buffer);
3965
3966         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
3967                                 (tdata->validCipherOffsetInBits.len >> 3);
3968         /* Validate obuf */
3969         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
3970                 ciphertext,
3971                 reference_ciphertext,
3972                 tdata->validCipherLenInBits.len,
3973                 "KASUMI Ciphertext data not as expected");
3974         return 0;
3975 }
3976
3977
3978 static int
3979 test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
3980 {
3981         struct crypto_testsuite_params *ts_params = &testsuite_params;
3982         struct crypto_unittest_params *ut_params = &unittest_params;
3983
3984         int retval;
3985         uint8_t *ciphertext, *plaintext;
3986         unsigned ciphertext_pad_len;
3987         unsigned ciphertext_len;
3988
3989         /* Verify the capabilities */
3990         struct rte_cryptodev_sym_capability_idx cap_idx;
3991         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3992         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
3993         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
3994                         &cap_idx) == NULL)
3995                 return TEST_SKIPPED;
3996
3997         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
3998                 return TEST_SKIPPED;
3999
4000         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4001                 return TEST_SKIPPED;
4002
4003         /* Create KASUMI session */
4004         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4005                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4006                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4007                                         tdata->key.data, tdata->key.len,
4008                                         tdata->cipher_iv.len);
4009         if (retval < 0)
4010                 return retval;
4011
4012         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4013         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4014
4015         /* Clear mbuf payload */
4016         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4017                rte_pktmbuf_tailroom(ut_params->ibuf));
4018
4019         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4020         /* Append data which is padded to a multiple */
4021         /* of the algorithms block size */
4022         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4023         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4024                                 ciphertext_pad_len);
4025         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4026         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4027
4028         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4029
4030         /* Create KASUMI operation */
4031         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4032                                 tdata->cipher_iv.len,
4033                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4034                                 tdata->validCipherOffsetInBits.len);
4035         if (retval < 0)
4036                 return retval;
4037
4038         ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4039                                                 ut_params->op);
4040         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4041
4042         ut_params->obuf = ut_params->op->sym->m_dst;
4043         if (ut_params->obuf)
4044                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4045         else
4046                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4047
4048         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4049
4050         const uint8_t *reference_plaintext = tdata->plaintext.data +
4051                                 (tdata->validCipherOffsetInBits.len >> 3);
4052         /* Validate obuf */
4053         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4054                 plaintext,
4055                 reference_plaintext,
4056                 tdata->validCipherLenInBits.len,
4057                 "KASUMI Plaintext data not as expected");
4058         return 0;
4059 }
4060
4061 static int
4062 test_kasumi_decryption(const struct kasumi_test_data *tdata)
4063 {
4064         struct crypto_testsuite_params *ts_params = &testsuite_params;
4065         struct crypto_unittest_params *ut_params = &unittest_params;
4066
4067         int retval;
4068         uint8_t *ciphertext, *plaintext;
4069         unsigned ciphertext_pad_len;
4070         unsigned ciphertext_len;
4071         struct rte_cryptodev_info dev_info;
4072
4073         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4074         uint64_t feat_flags = dev_info.feature_flags;
4075
4076         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4077                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4078                 printf("Device doesn't support RAW data-path APIs.\n");
4079                 return TEST_SKIPPED;
4080         }
4081
4082         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4083                 return TEST_SKIPPED;
4084
4085         /* Verify the capabilities */
4086         struct rte_cryptodev_sym_capability_idx cap_idx;
4087         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4088         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
4089         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4090                         &cap_idx) == NULL)
4091                 return TEST_SKIPPED;
4092
4093         /* Create KASUMI session */
4094         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4095                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4096                                         RTE_CRYPTO_CIPHER_KASUMI_F8,
4097                                         tdata->key.data, tdata->key.len,
4098                                         tdata->cipher_iv.len);
4099         if (retval < 0)
4100                 return retval;
4101
4102         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4103
4104         /* Clear mbuf payload */
4105         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4106                rte_pktmbuf_tailroom(ut_params->ibuf));
4107
4108         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4109         /* Append data which is padded to a multiple */
4110         /* of the algorithms block size */
4111         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 8);
4112         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4113                                 ciphertext_pad_len);
4114         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4115
4116         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4117
4118         /* Create KASUMI operation */
4119         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4120                         tdata->cipher_iv.len,
4121                         RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
4122                         tdata->validCipherOffsetInBits.len);
4123         if (retval < 0)
4124                 return retval;
4125
4126         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4127                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4128                                 ut_params->op, 1, 0, 1, 0);
4129         else
4130                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4131                                                 ut_params->op);
4132         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4133
4134         ut_params->obuf = ut_params->op->sym->m_dst;
4135         if (ut_params->obuf)
4136                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4137         else
4138                 plaintext = ciphertext + (tdata->validCipherOffsetInBits.len >> 3);
4139
4140         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4141
4142         const uint8_t *reference_plaintext = tdata->plaintext.data +
4143                                 (tdata->validCipherOffsetInBits.len >> 3);
4144         /* Validate obuf */
4145         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4146                 plaintext,
4147                 reference_plaintext,
4148                 tdata->validCipherLenInBits.len,
4149                 "KASUMI Plaintext data not as expected");
4150         return 0;
4151 }
4152
4153 static int
4154 test_snow3g_encryption(const struct snow3g_test_data *tdata)
4155 {
4156         struct crypto_testsuite_params *ts_params = &testsuite_params;
4157         struct crypto_unittest_params *ut_params = &unittest_params;
4158
4159         int retval;
4160         uint8_t *plaintext, *ciphertext;
4161         unsigned plaintext_pad_len;
4162         unsigned plaintext_len;
4163         struct rte_cryptodev_info dev_info;
4164
4165         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4166         uint64_t feat_flags = dev_info.feature_flags;
4167
4168         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4169                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4170                 printf("Device doesn't support RAW data-path APIs.\n");
4171                 return TEST_SKIPPED;
4172         }
4173
4174         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4175                 return TEST_SKIPPED;
4176
4177         /* Verify the capabilities */
4178         struct rte_cryptodev_sym_capability_idx cap_idx;
4179         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4180         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4181         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4182                         &cap_idx) == NULL)
4183                 return TEST_SKIPPED;
4184
4185         /* Create SNOW 3G session */
4186         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4187                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4188                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4189                                         tdata->key.data, tdata->key.len,
4190                                         tdata->cipher_iv.len);
4191         if (retval < 0)
4192                 return retval;
4193
4194         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4195
4196         /* Clear mbuf payload */
4197         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4198                rte_pktmbuf_tailroom(ut_params->ibuf));
4199
4200         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4201         /* Append data which is padded to a multiple of */
4202         /* the algorithms block size */
4203         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4204         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4205                                 plaintext_pad_len);
4206         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4207
4208         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4209
4210         /* Create SNOW 3G operation */
4211         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4212                                         tdata->cipher_iv.len,
4213                                         tdata->validCipherLenInBits.len,
4214                                         0);
4215         if (retval < 0)
4216                 return retval;
4217
4218         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4219                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4220                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4221         else
4222                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4223                                                 ut_params->op);
4224         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4225
4226         ut_params->obuf = ut_params->op->sym->m_dst;
4227         if (ut_params->obuf)
4228                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4229         else
4230                 ciphertext = plaintext;
4231
4232         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4233
4234         /* Validate obuf */
4235         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4236                 ciphertext,
4237                 tdata->ciphertext.data,
4238                 tdata->validDataLenInBits.len,
4239                 "SNOW 3G Ciphertext data not as expected");
4240         return 0;
4241 }
4242
4243
4244 static int
4245 test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
4246 {
4247         struct crypto_testsuite_params *ts_params = &testsuite_params;
4248         struct crypto_unittest_params *ut_params = &unittest_params;
4249         uint8_t *plaintext, *ciphertext;
4250
4251         int retval;
4252         unsigned plaintext_pad_len;
4253         unsigned plaintext_len;
4254         struct rte_cryptodev_info dev_info;
4255
4256         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4257         uint64_t feat_flags = dev_info.feature_flags;
4258
4259         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4260                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4261                 printf("Device does not support RAW data-path APIs.\n");
4262                 return -ENOTSUP;
4263         }
4264
4265         /* Verify the capabilities */
4266         struct rte_cryptodev_sym_capability_idx cap_idx;
4267         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4268         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4269         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4270                         &cap_idx) == NULL)
4271                 return TEST_SKIPPED;
4272
4273         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4274                 return TEST_SKIPPED;
4275
4276         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4277                 return TEST_SKIPPED;
4278
4279         /* Create SNOW 3G session */
4280         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4281                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4282                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4283                                         tdata->key.data, tdata->key.len,
4284                                         tdata->cipher_iv.len);
4285         if (retval < 0)
4286                 return retval;
4287
4288         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4289         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4290
4291         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4292                         "Failed to allocate input buffer in mempool");
4293         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4294                         "Failed to allocate output buffer in mempool");
4295
4296         /* Clear mbuf payload */
4297         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4298                rte_pktmbuf_tailroom(ut_params->ibuf));
4299
4300         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4301         /* Append data which is padded to a multiple of */
4302         /* the algorithms block size */
4303         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4304         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4305                                 plaintext_pad_len);
4306         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4307         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4308
4309         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4310
4311         /* Create SNOW 3G operation */
4312         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4313                                         tdata->cipher_iv.len,
4314                                         tdata->validCipherLenInBits.len,
4315                                         0);
4316         if (retval < 0)
4317                 return retval;
4318
4319         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4320                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4321                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4322         else
4323                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4324                                                 ut_params->op);
4325         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4326
4327         ut_params->obuf = ut_params->op->sym->m_dst;
4328         if (ut_params->obuf)
4329                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4330         else
4331                 ciphertext = plaintext;
4332
4333         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4334
4335         /* Validate obuf */
4336         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4337                 ciphertext,
4338                 tdata->ciphertext.data,
4339                 tdata->validDataLenInBits.len,
4340                 "SNOW 3G Ciphertext data not as expected");
4341         return 0;
4342 }
4343
4344 static int
4345 test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
4346 {
4347         struct crypto_testsuite_params *ts_params = &testsuite_params;
4348         struct crypto_unittest_params *ut_params = &unittest_params;
4349
4350         int retval;
4351         unsigned int plaintext_pad_len;
4352         unsigned int plaintext_len;
4353         uint8_t buffer[10000];
4354         const uint8_t *ciphertext;
4355
4356         struct rte_cryptodev_info dev_info;
4357
4358         /* Verify the capabilities */
4359         struct rte_cryptodev_sym_capability_idx cap_idx;
4360         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4361         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4362         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4363                         &cap_idx) == NULL)
4364                 return TEST_SKIPPED;
4365
4366         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4367                 return TEST_SKIPPED;
4368
4369         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4370                 return TEST_SKIPPED;
4371
4372         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4373
4374         uint64_t feat_flags = dev_info.feature_flags;
4375
4376         if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
4377                 printf("Device doesn't support out-of-place scatter-gather "
4378                                 "in both input and output mbufs. "
4379                                 "Test Skipped.\n");
4380                 return TEST_SKIPPED;
4381         }
4382
4383         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4384                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4385                 printf("Device does not support RAW data-path APIs.\n");
4386                 return -ENOTSUP;
4387         }
4388
4389         /* Create SNOW 3G session */
4390         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4391                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4392                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4393                                         tdata->key.data, tdata->key.len,
4394                                         tdata->cipher_iv.len);
4395         if (retval < 0)
4396                 return retval;
4397
4398         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4399         /* Append data which is padded to a multiple of */
4400         /* the algorithms block size */
4401         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4402
4403         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
4404                         plaintext_pad_len, 10, 0);
4405         ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
4406                         plaintext_pad_len, 3, 0);
4407
4408         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4409                         "Failed to allocate input buffer in mempool");
4410         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4411                         "Failed to allocate output buffer in mempool");
4412
4413         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
4414
4415         /* Create SNOW 3G operation */
4416         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4417                                         tdata->cipher_iv.len,
4418                                         tdata->validCipherLenInBits.len,
4419                                         0);
4420         if (retval < 0)
4421                 return retval;
4422
4423         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4424                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4425                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4426         else
4427                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4428                                                 ut_params->op);
4429         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4430
4431         ut_params->obuf = ut_params->op->sym->m_dst;
4432         if (ut_params->obuf)
4433                 ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
4434                                 plaintext_len, buffer);
4435         else
4436                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
4437                                 plaintext_len, buffer);
4438
4439         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4440
4441         /* Validate obuf */
4442         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4443                 ciphertext,
4444                 tdata->ciphertext.data,
4445                 tdata->validDataLenInBits.len,
4446                 "SNOW 3G Ciphertext data not as expected");
4447
4448         return 0;
4449 }
4450
4451 /* Shift right a buffer by "offset" bits, "offset" < 8 */
4452 static void
4453 buffer_shift_right(uint8_t *buffer, uint32_t length, uint8_t offset)
4454 {
4455         uint8_t curr_byte, prev_byte;
4456         uint32_t length_in_bytes = ceil_byte_length(length + offset);
4457         uint8_t lower_byte_mask = (1 << offset) - 1;
4458         unsigned i;
4459
4460         prev_byte = buffer[0];
4461         buffer[0] >>= offset;
4462
4463         for (i = 1; i < length_in_bytes; i++) {
4464                 curr_byte = buffer[i];
4465                 buffer[i] = ((prev_byte & lower_byte_mask) << (8 - offset)) |
4466                                 (curr_byte >> offset);
4467                 prev_byte = curr_byte;
4468         }
4469 }
4470
4471 static int
4472 test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
4473 {
4474         struct crypto_testsuite_params *ts_params = &testsuite_params;
4475         struct crypto_unittest_params *ut_params = &unittest_params;
4476         uint8_t *plaintext, *ciphertext;
4477         int retval;
4478         uint32_t plaintext_len;
4479         uint32_t plaintext_pad_len;
4480         uint8_t extra_offset = 4;
4481         uint8_t *expected_ciphertext_shifted;
4482         struct rte_cryptodev_info dev_info;
4483
4484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4485         uint64_t feat_flags = dev_info.feature_flags;
4486
4487         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4488                         ((tdata->validDataLenInBits.len % 8) != 0)) {
4489                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4490                 return TEST_SKIPPED;
4491         }
4492
4493         /* Verify the capabilities */
4494         struct rte_cryptodev_sym_capability_idx cap_idx;
4495         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4496         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4497         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4498                         &cap_idx) == NULL)
4499                 return TEST_SKIPPED;
4500
4501         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4502                 return TEST_SKIPPED;
4503
4504         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4505                 return TEST_SKIPPED;
4506
4507         /* Create SNOW 3G session */
4508         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4509                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4510                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4511                                         tdata->key.data, tdata->key.len,
4512                                         tdata->cipher_iv.len);
4513         if (retval < 0)
4514                 return retval;
4515
4516         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4517         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4518
4519         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4520                         "Failed to allocate input buffer in mempool");
4521         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4522                         "Failed to allocate output buffer in mempool");
4523
4524         /* Clear mbuf payload */
4525         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4526                rte_pktmbuf_tailroom(ut_params->ibuf));
4527
4528         plaintext_len = ceil_byte_length(tdata->plaintext.len + extra_offset);
4529         /*
4530          * Append data which is padded to a
4531          * multiple of the algorithms block size
4532          */
4533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4534
4535         plaintext = (uint8_t *) rte_pktmbuf_append(ut_params->ibuf,
4536                                                 plaintext_pad_len);
4537
4538         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
4539
4540         memcpy(plaintext, tdata->plaintext.data, (tdata->plaintext.len >> 3));
4541         buffer_shift_right(plaintext, tdata->plaintext.len, extra_offset);
4542
4543 #ifdef RTE_APP_TEST_DEBUG
4544         rte_hexdump(stdout, "plaintext:", plaintext, tdata->plaintext.len);
4545 #endif
4546         /* Create SNOW 3G operation */
4547         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4548                                         tdata->cipher_iv.len,
4549                                         tdata->validCipherLenInBits.len,
4550                                         extra_offset);
4551         if (retval < 0)
4552                 return retval;
4553
4554         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4555                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4556                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4557         else
4558                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4559                                                 ut_params->op);
4560         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4561
4562         ut_params->obuf = ut_params->op->sym->m_dst;
4563         if (ut_params->obuf)
4564                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4565         else
4566                 ciphertext = plaintext;
4567
4568 #ifdef RTE_APP_TEST_DEBUG
4569         rte_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4570 #endif
4571
4572         expected_ciphertext_shifted = rte_malloc(NULL, plaintext_len, 8);
4573
4574         TEST_ASSERT_NOT_NULL(expected_ciphertext_shifted,
4575                         "failed to reserve memory for ciphertext shifted\n");
4576
4577         memcpy(expected_ciphertext_shifted, tdata->ciphertext.data,
4578                         ceil_byte_length(tdata->ciphertext.len));
4579         buffer_shift_right(expected_ciphertext_shifted, tdata->ciphertext.len,
4580                         extra_offset);
4581         /* Validate obuf */
4582         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
4583                 ciphertext,
4584                 expected_ciphertext_shifted,
4585                 tdata->validDataLenInBits.len,
4586                 extra_offset,
4587                 "SNOW 3G Ciphertext data not as expected");
4588         return 0;
4589 }
4590
4591 static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
4592 {
4593         struct crypto_testsuite_params *ts_params = &testsuite_params;
4594         struct crypto_unittest_params *ut_params = &unittest_params;
4595
4596         int retval;
4597
4598         uint8_t *plaintext, *ciphertext;
4599         unsigned ciphertext_pad_len;
4600         unsigned ciphertext_len;
4601         struct rte_cryptodev_info dev_info;
4602
4603         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4604         uint64_t feat_flags = dev_info.feature_flags;
4605
4606         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4607                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4608                 printf("Device doesn't support RAW data-path APIs.\n");
4609                 return TEST_SKIPPED;
4610         }
4611
4612         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4613                 return TEST_SKIPPED;
4614
4615         /* Verify the capabilities */
4616         struct rte_cryptodev_sym_capability_idx cap_idx;
4617         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4618         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4619         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4620                         &cap_idx) == NULL)
4621                 return TEST_SKIPPED;
4622
4623         /* Create SNOW 3G session */
4624         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4625                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4626                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4627                                         tdata->key.data, tdata->key.len,
4628                                         tdata->cipher_iv.len);
4629         if (retval < 0)
4630                 return retval;
4631
4632         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4633
4634         /* Clear mbuf payload */
4635         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4636                rte_pktmbuf_tailroom(ut_params->ibuf));
4637
4638         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4639         /* Append data which is padded to a multiple of */
4640         /* the algorithms block size */
4641         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4642         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4643                                 ciphertext_pad_len);
4644         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4645
4646         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4647
4648         /* Create SNOW 3G operation */
4649         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
4650                                         tdata->cipher_iv.len,
4651                                         tdata->validCipherLenInBits.len,
4652                                         tdata->cipher.offset_bits);
4653         if (retval < 0)
4654                 return retval;
4655
4656         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4657                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4658                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4659         else
4660                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4661                                                 ut_params->op);
4662         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4663         ut_params->obuf = ut_params->op->sym->m_dst;
4664         if (ut_params->obuf)
4665                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4666         else
4667                 plaintext = ciphertext;
4668
4669         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4670
4671         /* Validate obuf */
4672         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4673                                 tdata->plaintext.data,
4674                                 tdata->validDataLenInBits.len,
4675                                 "SNOW 3G Plaintext data not as expected");
4676         return 0;
4677 }
4678
4679 static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
4680 {
4681         struct crypto_testsuite_params *ts_params = &testsuite_params;
4682         struct crypto_unittest_params *ut_params = &unittest_params;
4683
4684         int retval;
4685
4686         uint8_t *plaintext, *ciphertext;
4687         unsigned ciphertext_pad_len;
4688         unsigned ciphertext_len;
4689         struct rte_cryptodev_info dev_info;
4690
4691         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4692         uint64_t feat_flags = dev_info.feature_flags;
4693
4694         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4695                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4696                 printf("Device does not support RAW data-path APIs.\n");
4697                 return -ENOTSUP;
4698         }
4699         /* Verify the capabilities */
4700         struct rte_cryptodev_sym_capability_idx cap_idx;
4701         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4702         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4703         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4704                         &cap_idx) == NULL)
4705                 return TEST_SKIPPED;
4706
4707         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4708                 return TEST_SKIPPED;
4709
4710         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4711                 return TEST_SKIPPED;
4712
4713         /* Create SNOW 3G session */
4714         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
4715                                         RTE_CRYPTO_CIPHER_OP_DECRYPT,
4716                                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4717                                         tdata->key.data, tdata->key.len,
4718                                         tdata->cipher_iv.len);
4719         if (retval < 0)
4720                 return retval;
4721
4722         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4723         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4724
4725         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
4726                         "Failed to allocate input buffer");
4727         TEST_ASSERT_NOT_NULL(ut_params->obuf,
4728                         "Failed to allocate output buffer");
4729
4730         /* Clear mbuf payload */
4731         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4732                rte_pktmbuf_tailroom(ut_params->ibuf));
4733
4734         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
4735                        rte_pktmbuf_tailroom(ut_params->obuf));
4736
4737         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
4738         /* Append data which is padded to a multiple of */
4739         /* the algorithms block size */
4740         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
4741         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4742                                 ciphertext_pad_len);
4743         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
4744         memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
4745
4746         debug_hexdump(stdout, "ciphertext:", ciphertext, ciphertext_len);
4747
4748         /* Create SNOW 3G operation */
4749         retval = create_wireless_algo_cipher_operation_oop(tdata->cipher_iv.data,
4750                                         tdata->cipher_iv.len,
4751                                         tdata->validCipherLenInBits.len,
4752                                         0);
4753         if (retval < 0)
4754                 return retval;
4755
4756         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4757                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4758                         ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
4759         else
4760                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4761                                                 ut_params->op);
4762         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4763         ut_params->obuf = ut_params->op->sym->m_dst;
4764         if (ut_params->obuf)
4765                 plaintext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4766         else
4767                 plaintext = ciphertext;
4768
4769         debug_hexdump(stdout, "plaintext:", plaintext, ciphertext_len);
4770
4771         /* Validate obuf */
4772         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(plaintext,
4773                                 tdata->plaintext.data,
4774                                 tdata->validDataLenInBits.len,
4775                                 "SNOW 3G Plaintext data not as expected");
4776         return 0;
4777 }
4778
4779 static int
4780 test_zuc_cipher_auth(const struct wireless_test_data *tdata)
4781 {
4782         struct crypto_testsuite_params *ts_params = &testsuite_params;
4783         struct crypto_unittest_params *ut_params = &unittest_params;
4784
4785         int retval;
4786
4787         uint8_t *plaintext, *ciphertext;
4788         unsigned int plaintext_pad_len;
4789         unsigned int plaintext_len;
4790
4791         struct rte_cryptodev_info dev_info;
4792         struct rte_cryptodev_sym_capability_idx cap_idx;
4793
4794         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4795         uint64_t feat_flags = dev_info.feature_flags;
4796
4797         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
4798                         ((tdata->validAuthLenInBits.len % 8 != 0) ||
4799                         (tdata->validDataLenInBits.len % 8 != 0))) {
4800                 printf("Device doesn't support NON-Byte Aligned Data.\n");
4801                 return TEST_SKIPPED;
4802         }
4803
4804         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4805                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4806                 printf("Device doesn't support RAW data-path APIs.\n");
4807                 return TEST_SKIPPED;
4808         }
4809
4810         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4811                 return TEST_SKIPPED;
4812
4813         /* Check if device supports ZUC EEA3 */
4814         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4815         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
4816
4817         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4818                         &cap_idx) == NULL)
4819                 return TEST_SKIPPED;
4820
4821         /* Check if device supports ZUC EIA3 */
4822         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4823         cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
4824
4825         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4826                         &cap_idx) == NULL)
4827                 return TEST_SKIPPED;
4828
4829         /* Create ZUC session */
4830         retval = create_zuc_cipher_auth_encrypt_generate_session(
4831                         ts_params->valid_devs[0],
4832                         tdata);
4833         if (retval != 0)
4834                 return retval;
4835         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4836
4837         /* clear mbuf payload */
4838         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4839                         rte_pktmbuf_tailroom(ut_params->ibuf));
4840
4841         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4842         /* Append data which is padded to a multiple of */
4843         /* the algorithms block size */
4844         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4845         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4846                                 plaintext_pad_len);
4847         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4848
4849         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4850
4851         /* Create ZUC operation */
4852         retval = create_zuc_cipher_hash_generate_operation(tdata);
4853         if (retval < 0)
4854                 return retval;
4855
4856         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4857                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4858                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4859         else
4860                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4861                         ut_params->op);
4862         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4863         ut_params->obuf = ut_params->op->sym->m_src;
4864         if (ut_params->obuf)
4865                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4866         else
4867                 ciphertext = plaintext;
4868
4869         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4870         /* Validate obuf */
4871         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4872                         ciphertext,
4873                         tdata->ciphertext.data,
4874                         tdata->validDataLenInBits.len,
4875                         "ZUC Ciphertext data not as expected");
4876
4877         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4878             + plaintext_pad_len;
4879
4880         /* Validate obuf */
4881         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4882                         ut_params->digest,
4883                         tdata->digest.data,
4884                         4,
4885                         "ZUC Generated auth tag not as expected");
4886         return 0;
4887 }
4888
4889 static int
4890 test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
4891 {
4892         struct crypto_testsuite_params *ts_params = &testsuite_params;
4893         struct crypto_unittest_params *ut_params = &unittest_params;
4894
4895         int retval;
4896
4897         uint8_t *plaintext, *ciphertext;
4898         unsigned plaintext_pad_len;
4899         unsigned plaintext_len;
4900         struct rte_cryptodev_info dev_info;
4901
4902         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
4903         uint64_t feat_flags = dev_info.feature_flags;
4904
4905         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
4906                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
4907                 printf("Device doesn't support RAW data-path APIs.\n");
4908                 return TEST_SKIPPED;
4909         }
4910
4911         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
4912                 return TEST_SKIPPED;
4913
4914         /* Verify the capabilities */
4915         struct rte_cryptodev_sym_capability_idx cap_idx;
4916         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4917         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
4918         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4919                         &cap_idx) == NULL)
4920                 return TEST_SKIPPED;
4921         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4922         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
4923         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
4924                         &cap_idx) == NULL)
4925                 return TEST_SKIPPED;
4926
4927         /* Create SNOW 3G session */
4928         retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
4929                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
4930                         RTE_CRYPTO_AUTH_OP_GENERATE,
4931                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
4932                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
4933                         tdata->key.data, tdata->key.len,
4934                         tdata->auth_iv.len, tdata->digest.len,
4935                         tdata->cipher_iv.len);
4936         if (retval != 0)
4937                 return retval;
4938         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
4939
4940         /* clear mbuf payload */
4941         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
4942                         rte_pktmbuf_tailroom(ut_params->ibuf));
4943
4944         plaintext_len = ceil_byte_length(tdata->plaintext.len);
4945         /* Append data which is padded to a multiple of */
4946         /* the algorithms block size */
4947         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
4948         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
4949                                 plaintext_pad_len);
4950         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
4951
4952         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
4953
4954         /* Create SNOW 3G operation */
4955         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
4956                         tdata->digest.len, tdata->auth_iv.data,
4957                         tdata->auth_iv.len,
4958                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
4959                         tdata->cipher_iv.data, tdata->cipher_iv.len,
4960                         tdata->validCipherLenInBits.len,
4961                         0,
4962                         tdata->validAuthLenInBits.len,
4963                         0
4964                         );
4965         if (retval < 0)
4966                 return retval;
4967
4968         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
4969                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
4970                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
4971         else
4972                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
4973                         ut_params->op);
4974         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
4975         ut_params->obuf = ut_params->op->sym->m_src;
4976         if (ut_params->obuf)
4977                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
4978         else
4979                 ciphertext = plaintext;
4980
4981         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
4982         /* Validate obuf */
4983         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
4984                         ciphertext,
4985                         tdata->ciphertext.data,
4986                         tdata->validDataLenInBits.len,
4987                         "SNOW 3G Ciphertext data not as expected");
4988
4989         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
4990             + plaintext_pad_len;
4991
4992         /* Validate obuf */
4993         TEST_ASSERT_BUFFERS_ARE_EQUAL(
4994                         ut_params->digest,
4995                         tdata->digest.data,
4996                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
4997                         "SNOW 3G Generated auth tag not as expected");
4998         return 0;
4999 }
5000
5001 static int
5002 test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
5003         uint8_t op_mode, uint8_t verify)
5004 {
5005         struct crypto_testsuite_params *ts_params = &testsuite_params;
5006         struct crypto_unittest_params *ut_params = &unittest_params;
5007
5008         int retval;
5009
5010         uint8_t *plaintext = NULL, *ciphertext = NULL;
5011         unsigned int plaintext_pad_len;
5012         unsigned int plaintext_len;
5013         unsigned int ciphertext_pad_len;
5014         unsigned int ciphertext_len;
5015
5016         struct rte_cryptodev_info dev_info;
5017
5018         /* Verify the capabilities */
5019         struct rte_cryptodev_sym_capability_idx cap_idx;
5020         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5021         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5022         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5023                         &cap_idx) == NULL)
5024                 return TEST_SKIPPED;
5025         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5026         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5027         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5028                         &cap_idx) == NULL)
5029                 return TEST_SKIPPED;
5030
5031         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5032                 return TEST_SKIPPED;
5033
5034         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5035
5036         uint64_t feat_flags = dev_info.feature_flags;
5037
5038         if (op_mode == OUT_OF_PLACE) {
5039                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5040                         printf("Device doesn't support digest encrypted.\n");
5041                         return TEST_SKIPPED;
5042                 }
5043                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5044                         return TEST_SKIPPED;
5045         }
5046
5047         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5048                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5049                 printf("Device doesn't support RAW data-path APIs.\n");
5050                 return TEST_SKIPPED;
5051         }
5052
5053         /* Create SNOW 3G session */
5054         retval = create_wireless_algo_auth_cipher_session(
5055                         ts_params->valid_devs[0],
5056                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5057                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5058                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5059                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5060                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5061                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5062                         tdata->key.data, tdata->key.len,
5063                         tdata->auth_iv.len, tdata->digest.len,
5064                         tdata->cipher_iv.len);
5065         if (retval != 0)
5066                 return retval;
5067
5068         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5069         if (op_mode == OUT_OF_PLACE)
5070                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5071
5072         /* clear mbuf payload */
5073         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5074                 rte_pktmbuf_tailroom(ut_params->ibuf));
5075         if (op_mode == OUT_OF_PLACE)
5076                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5077                         rte_pktmbuf_tailroom(ut_params->obuf));
5078
5079         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5080         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5081         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5082         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5083
5084         if (verify) {
5085                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5086                                         ciphertext_pad_len);
5087                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5088                 if (op_mode == OUT_OF_PLACE)
5089                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5090                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5091                         ciphertext_len);
5092         } else {
5093                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5094                                         plaintext_pad_len);
5095                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5096                 if (op_mode == OUT_OF_PLACE)
5097                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5098                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5099         }
5100
5101         /* Create SNOW 3G operation */
5102         retval = create_wireless_algo_auth_cipher_operation(
5103                 tdata->digest.data, tdata->digest.len,
5104                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5105                 tdata->auth_iv.data, tdata->auth_iv.len,
5106                 (tdata->digest.offset_bytes == 0 ?
5107                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5108                         : tdata->digest.offset_bytes),
5109                 tdata->validCipherLenInBits.len,
5110                 tdata->cipher.offset_bits,
5111                 tdata->validAuthLenInBits.len,
5112                 tdata->auth.offset_bits,
5113                 op_mode, 0, verify);
5114
5115         if (retval < 0)
5116                 return retval;
5117
5118         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5119                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5120                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5121         else
5122                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5123                         ut_params->op);
5124
5125         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5126
5127         ut_params->obuf = (op_mode == IN_PLACE ?
5128                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5129
5130         if (verify) {
5131                 if (ut_params->obuf)
5132                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5133                                                         uint8_t *);
5134                 else
5135                         plaintext = ciphertext +
5136                                 (tdata->cipher.offset_bits >> 3);
5137
5138                 debug_hexdump(stdout, "plaintext:", plaintext,
5139                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5140                 debug_hexdump(stdout, "plaintext expected:",
5141                         tdata->plaintext.data,
5142                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5143         } else {
5144                 if (ut_params->obuf)
5145                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5146                                                         uint8_t *);
5147                 else
5148                         ciphertext = plaintext;
5149
5150                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5151                         ciphertext_len);
5152                 debug_hexdump(stdout, "ciphertext expected:",
5153                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5154
5155                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5156                         + (tdata->digest.offset_bytes == 0 ?
5157                 plaintext_pad_len : tdata->digest.offset_bytes);
5158
5159                 debug_hexdump(stdout, "digest:", ut_params->digest,
5160                         tdata->digest.len);
5161                 debug_hexdump(stdout, "digest expected:", tdata->digest.data,
5162                                 tdata->digest.len);
5163         }
5164
5165         /* Validate obuf */
5166         if (verify) {
5167                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5168                         plaintext,
5169                         tdata->plaintext.data,
5170                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5171                          (tdata->digest.len << 3)),
5172                         tdata->cipher.offset_bits,
5173                         "SNOW 3G Plaintext data not as expected");
5174         } else {
5175                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5176                         ciphertext,
5177                         tdata->ciphertext.data,
5178                         (tdata->validDataLenInBits.len -
5179                          tdata->cipher.offset_bits),
5180                         tdata->cipher.offset_bits,
5181                         "SNOW 3G Ciphertext data not as expected");
5182
5183                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5184                         ut_params->digest,
5185                         tdata->digest.data,
5186                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5187                         "SNOW 3G Generated auth tag not as expected");
5188         }
5189         return 0;
5190 }
5191
5192 static int
5193 test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
5194         uint8_t op_mode, uint8_t verify)
5195 {
5196         struct crypto_testsuite_params *ts_params = &testsuite_params;
5197         struct crypto_unittest_params *ut_params = &unittest_params;
5198
5199         int retval;
5200
5201         const uint8_t *plaintext = NULL;
5202         const uint8_t *ciphertext = NULL;
5203         const uint8_t *digest = NULL;
5204         unsigned int plaintext_pad_len;
5205         unsigned int plaintext_len;
5206         unsigned int ciphertext_pad_len;
5207         unsigned int ciphertext_len;
5208         uint8_t buffer[10000];
5209         uint8_t digest_buffer[10000];
5210
5211         struct rte_cryptodev_info dev_info;
5212
5213         /* Verify the capabilities */
5214         struct rte_cryptodev_sym_capability_idx cap_idx;
5215         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5216         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
5217         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5218                         &cap_idx) == NULL)
5219                 return TEST_SKIPPED;
5220         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5221         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
5222         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5223                         &cap_idx) == NULL)
5224                 return TEST_SKIPPED;
5225
5226         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5227                 return TEST_SKIPPED;
5228
5229         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5230
5231         uint64_t feat_flags = dev_info.feature_flags;
5232
5233         if (op_mode == IN_PLACE) {
5234                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5235                         printf("Device doesn't support in-place scatter-gather "
5236                                         "in both input and output mbufs.\n");
5237                         return TEST_SKIPPED;
5238                 }
5239                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5240                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5241                         printf("Device doesn't support RAW data-path APIs.\n");
5242                         return TEST_SKIPPED;
5243                 }
5244         } else {
5245                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5246                         return TEST_SKIPPED;
5247                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5248                         printf("Device doesn't support out-of-place scatter-gather "
5249                                         "in both input and output mbufs.\n");
5250                         return TEST_SKIPPED;
5251                 }
5252                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5253                         printf("Device doesn't support digest encrypted.\n");
5254                         return TEST_SKIPPED;
5255                 }
5256         }
5257
5258         /* Create SNOW 3G session */
5259         retval = create_wireless_algo_auth_cipher_session(
5260                         ts_params->valid_devs[0],
5261                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5262                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5263                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5264                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5265                         RTE_CRYPTO_AUTH_SNOW3G_UIA2,
5266                         RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
5267                         tdata->key.data, tdata->key.len,
5268                         tdata->auth_iv.len, tdata->digest.len,
5269                         tdata->cipher_iv.len);
5270
5271         if (retval != 0)
5272                 return retval;
5273
5274         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5275         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5276         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5277         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5278
5279         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5280                         plaintext_pad_len, 15, 0);
5281         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5282                         "Failed to allocate input buffer in mempool");
5283
5284         if (op_mode == OUT_OF_PLACE) {
5285                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5286                                 plaintext_pad_len, 15, 0);
5287                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5288                                 "Failed to allocate output buffer in mempool");
5289         }
5290
5291         if (verify) {
5292                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5293                         tdata->ciphertext.data);
5294                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5295                                         ciphertext_len, buffer);
5296                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5297                         ciphertext_len);
5298         } else {
5299                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5300                         tdata->plaintext.data);
5301                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5302                                         plaintext_len, buffer);
5303                 debug_hexdump(stdout, "plaintext:", plaintext,
5304                         plaintext_len);
5305         }
5306         memset(buffer, 0, sizeof(buffer));
5307
5308         /* Create SNOW 3G operation */
5309         retval = create_wireless_algo_auth_cipher_operation(
5310                 tdata->digest.data, tdata->digest.len,
5311                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5312                 tdata->auth_iv.data, tdata->auth_iv.len,
5313                 (tdata->digest.offset_bytes == 0 ?
5314                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5315                         : tdata->digest.offset_bytes),
5316                 tdata->validCipherLenInBits.len,
5317                 tdata->cipher.offset_bits,
5318                 tdata->validAuthLenInBits.len,
5319                 tdata->auth.offset_bits,
5320                 op_mode, 1, verify);
5321
5322         if (retval < 0)
5323                 return retval;
5324
5325         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5326                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5327                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5328         else
5329                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5330                         ut_params->op);
5331
5332         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5333
5334         ut_params->obuf = (op_mode == IN_PLACE ?
5335                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5336
5337         if (verify) {
5338                 if (ut_params->obuf)
5339                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5340                                         plaintext_len, buffer);
5341                 else
5342                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5343                                         plaintext_len, buffer);
5344
5345                 debug_hexdump(stdout, "plaintext:", plaintext,
5346                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5347                 debug_hexdump(stdout, "plaintext expected:",
5348                         tdata->plaintext.data,
5349                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5350         } else {
5351                 if (ut_params->obuf)
5352                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5353                                         ciphertext_len, buffer);
5354                 else
5355                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5356                                         ciphertext_len, buffer);
5357
5358                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5359                         ciphertext_len);
5360                 debug_hexdump(stdout, "ciphertext expected:",
5361                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5362
5363                 if (ut_params->obuf)
5364                         digest = rte_pktmbuf_read(ut_params->obuf,
5365                                 (tdata->digest.offset_bytes == 0 ?
5366                                 plaintext_pad_len : tdata->digest.offset_bytes),
5367                                 tdata->digest.len, digest_buffer);
5368                 else
5369                         digest = rte_pktmbuf_read(ut_params->ibuf,
5370                                 (tdata->digest.offset_bytes == 0 ?
5371                                 plaintext_pad_len : tdata->digest.offset_bytes),
5372                                 tdata->digest.len, digest_buffer);
5373
5374                 debug_hexdump(stdout, "digest:", digest,
5375                         tdata->digest.len);
5376                 debug_hexdump(stdout, "digest expected:",
5377                         tdata->digest.data, tdata->digest.len);
5378         }
5379
5380         /* Validate obuf */
5381         if (verify) {
5382                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5383                         plaintext,
5384                         tdata->plaintext.data,
5385                         (tdata->plaintext.len - tdata->cipher.offset_bits -
5386                          (tdata->digest.len << 3)),
5387                         tdata->cipher.offset_bits,
5388                         "SNOW 3G Plaintext data not as expected");
5389         } else {
5390                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
5391                         ciphertext,
5392                         tdata->ciphertext.data,
5393                         (tdata->validDataLenInBits.len -
5394                          tdata->cipher.offset_bits),
5395                         tdata->cipher.offset_bits,
5396                         "SNOW 3G Ciphertext data not as expected");
5397
5398                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5399                         digest,
5400                         tdata->digest.data,
5401                         DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5402                         "SNOW 3G Generated auth tag not as expected");
5403         }
5404         return 0;
5405 }
5406
5407 static int
5408 test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
5409         uint8_t op_mode, uint8_t verify)
5410 {
5411         struct crypto_testsuite_params *ts_params = &testsuite_params;
5412         struct crypto_unittest_params *ut_params = &unittest_params;
5413
5414         int retval;
5415
5416         uint8_t *plaintext = NULL, *ciphertext = NULL;
5417         unsigned int plaintext_pad_len;
5418         unsigned int plaintext_len;
5419         unsigned int ciphertext_pad_len;
5420         unsigned int ciphertext_len;
5421
5422         struct rte_cryptodev_info dev_info;
5423
5424         /* Verify the capabilities */
5425         struct rte_cryptodev_sym_capability_idx cap_idx;
5426         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5427         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5428         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5429                         &cap_idx) == NULL)
5430                 return TEST_SKIPPED;
5431         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5432         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5433         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5434                         &cap_idx) == NULL)
5435                 return TEST_SKIPPED;
5436
5437         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5438
5439         uint64_t feat_flags = dev_info.feature_flags;
5440
5441         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5442                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5443                 printf("Device doesn't support RAW data-path APIs.\n");
5444                 return TEST_SKIPPED;
5445         }
5446
5447         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5448                 return TEST_SKIPPED;
5449
5450         if (op_mode == OUT_OF_PLACE) {
5451                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5452                         return TEST_SKIPPED;
5453                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5454                         printf("Device doesn't support digest encrypted.\n");
5455                         return TEST_SKIPPED;
5456                 }
5457         }
5458
5459         /* Create KASUMI session */
5460         retval = create_wireless_algo_auth_cipher_session(
5461                         ts_params->valid_devs[0],
5462                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5463                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5464                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5465                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5466                         RTE_CRYPTO_AUTH_KASUMI_F9,
5467                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5468                         tdata->key.data, tdata->key.len,
5469                         0, tdata->digest.len,
5470                         tdata->cipher_iv.len);
5471
5472         if (retval != 0)
5473                 return retval;
5474
5475         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5476         if (op_mode == OUT_OF_PLACE)
5477                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5478
5479         /* clear mbuf payload */
5480         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5481                 rte_pktmbuf_tailroom(ut_params->ibuf));
5482         if (op_mode == OUT_OF_PLACE)
5483                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
5484                         rte_pktmbuf_tailroom(ut_params->obuf));
5485
5486         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5487         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5488         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5489         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5490
5491         if (verify) {
5492                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5493                                         ciphertext_pad_len);
5494                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
5495                 if (op_mode == OUT_OF_PLACE)
5496                         rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
5497                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5498                         ciphertext_len);
5499         } else {
5500                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5501                                         plaintext_pad_len);
5502                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5503                 if (op_mode == OUT_OF_PLACE)
5504                         rte_pktmbuf_append(ut_params->obuf, plaintext_pad_len);
5505                 debug_hexdump(stdout, "plaintext:", plaintext,
5506                         plaintext_len);
5507         }
5508
5509         /* Create KASUMI operation */
5510         retval = create_wireless_algo_auth_cipher_operation(
5511                 tdata->digest.data, tdata->digest.len,
5512                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5513                 NULL, 0,
5514                 (tdata->digest.offset_bytes == 0 ?
5515                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5516                         : tdata->digest.offset_bytes),
5517                 tdata->validCipherLenInBits.len,
5518                 tdata->validCipherOffsetInBits.len,
5519                 tdata->validAuthLenInBits.len,
5520                 0,
5521                 op_mode, 0, verify);
5522
5523         if (retval < 0)
5524                 return retval;
5525
5526         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5527                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5528                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5529         else
5530                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5531                         ut_params->op);
5532
5533         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5534
5535         ut_params->obuf = (op_mode == IN_PLACE ?
5536                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5537
5538
5539         if (verify) {
5540                 if (ut_params->obuf)
5541                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
5542                                                         uint8_t *);
5543                 else
5544                         plaintext = ciphertext;
5545
5546                 debug_hexdump(stdout, "plaintext:", plaintext,
5547                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5548                 debug_hexdump(stdout, "plaintext expected:",
5549                         tdata->plaintext.data,
5550                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5551         } else {
5552                 if (ut_params->obuf)
5553                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
5554                                                         uint8_t *);
5555                 else
5556                         ciphertext = plaintext;
5557
5558                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5559                         ciphertext_len);
5560                 debug_hexdump(stdout, "ciphertext expected:",
5561                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5562
5563                 ut_params->digest = rte_pktmbuf_mtod(
5564                         ut_params->obuf, uint8_t *) +
5565                         (tdata->digest.offset_bytes == 0 ?
5566                         plaintext_pad_len : tdata->digest.offset_bytes);
5567
5568                 debug_hexdump(stdout, "digest:", ut_params->digest,
5569                         tdata->digest.len);
5570                 debug_hexdump(stdout, "digest expected:",
5571                         tdata->digest.data, tdata->digest.len);
5572         }
5573
5574         /* Validate obuf */
5575         if (verify) {
5576                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5577                         plaintext,
5578                         tdata->plaintext.data,
5579                         tdata->plaintext.len >> 3,
5580                         "KASUMI Plaintext data not as expected");
5581         } else {
5582                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5583                         ciphertext,
5584                         tdata->ciphertext.data,
5585                         tdata->ciphertext.len >> 3,
5586                         "KASUMI Ciphertext data not as expected");
5587
5588                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5589                         ut_params->digest,
5590                         tdata->digest.data,
5591                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5592                         "KASUMI Generated auth tag not as expected");
5593         }
5594         return 0;
5595 }
5596
5597 static int
5598 test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
5599         uint8_t op_mode, uint8_t verify)
5600 {
5601         struct crypto_testsuite_params *ts_params = &testsuite_params;
5602         struct crypto_unittest_params *ut_params = &unittest_params;
5603
5604         int retval;
5605
5606         const uint8_t *plaintext = NULL;
5607         const uint8_t *ciphertext = NULL;
5608         const uint8_t *digest = NULL;
5609         unsigned int plaintext_pad_len;
5610         unsigned int plaintext_len;
5611         unsigned int ciphertext_pad_len;
5612         unsigned int ciphertext_len;
5613         uint8_t buffer[10000];
5614         uint8_t digest_buffer[10000];
5615
5616         struct rte_cryptodev_info dev_info;
5617
5618         /* Verify the capabilities */
5619         struct rte_cryptodev_sym_capability_idx cap_idx;
5620         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5621         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5622         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5623                         &cap_idx) == NULL)
5624                 return TEST_SKIPPED;
5625         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5626         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5627         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5628                         &cap_idx) == NULL)
5629                 return TEST_SKIPPED;
5630
5631         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5632                 return TEST_SKIPPED;
5633
5634         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5635
5636         uint64_t feat_flags = dev_info.feature_flags;
5637
5638         if (op_mode == IN_PLACE) {
5639                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
5640                         printf("Device doesn't support in-place scatter-gather "
5641                                         "in both input and output mbufs.\n");
5642                         return TEST_SKIPPED;
5643                 }
5644                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5645                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5646                         printf("Device doesn't support RAW data-path APIs.\n");
5647                         return TEST_SKIPPED;
5648                 }
5649         } else {
5650                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5651                         return TEST_SKIPPED;
5652                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
5653                         printf("Device doesn't support out-of-place scatter-gather "
5654                                         "in both input and output mbufs.\n");
5655                         return TEST_SKIPPED;
5656                 }
5657                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
5658                         printf("Device doesn't support digest encrypted.\n");
5659                         return TEST_SKIPPED;
5660                 }
5661         }
5662
5663         /* Create KASUMI session */
5664         retval = create_wireless_algo_auth_cipher_session(
5665                         ts_params->valid_devs[0],
5666                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
5667                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
5668                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
5669                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
5670                         RTE_CRYPTO_AUTH_KASUMI_F9,
5671                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5672                         tdata->key.data, tdata->key.len,
5673                         0, tdata->digest.len,
5674                         tdata->cipher_iv.len);
5675
5676         if (retval != 0)
5677                 return retval;
5678
5679         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
5680         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5681         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
5682         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5683
5684         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
5685                         plaintext_pad_len, 15, 0);
5686         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
5687                         "Failed to allocate input buffer in mempool");
5688
5689         if (op_mode == OUT_OF_PLACE) {
5690                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
5691                                 plaintext_pad_len, 15, 0);
5692                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
5693                                 "Failed to allocate output buffer in mempool");
5694         }
5695
5696         if (verify) {
5697                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
5698                         tdata->ciphertext.data);
5699                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5700                                         ciphertext_len, buffer);
5701                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5702                         ciphertext_len);
5703         } else {
5704                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
5705                         tdata->plaintext.data);
5706                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5707                                         plaintext_len, buffer);
5708                 debug_hexdump(stdout, "plaintext:", plaintext,
5709                         plaintext_len);
5710         }
5711         memset(buffer, 0, sizeof(buffer));
5712
5713         /* Create KASUMI operation */
5714         retval = create_wireless_algo_auth_cipher_operation(
5715                 tdata->digest.data, tdata->digest.len,
5716                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5717                 NULL, 0,
5718                 (tdata->digest.offset_bytes == 0 ?
5719                 (verify ? ciphertext_pad_len : plaintext_pad_len)
5720                         : tdata->digest.offset_bytes),
5721                 tdata->validCipherLenInBits.len,
5722                 tdata->validCipherOffsetInBits.len,
5723                 tdata->validAuthLenInBits.len,
5724                 0,
5725                 op_mode, 1, verify);
5726
5727         if (retval < 0)
5728                 return retval;
5729
5730         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5731                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5732                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5733         else
5734                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5735                         ut_params->op);
5736
5737         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5738
5739         ut_params->obuf = (op_mode == IN_PLACE ?
5740                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
5741
5742         if (verify) {
5743                 if (ut_params->obuf)
5744                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
5745                                         plaintext_len, buffer);
5746                 else
5747                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
5748                                         plaintext_len, buffer);
5749
5750                 debug_hexdump(stdout, "plaintext:", plaintext,
5751                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5752                 debug_hexdump(stdout, "plaintext expected:",
5753                         tdata->plaintext.data,
5754                         (tdata->plaintext.len >> 3) - tdata->digest.len);
5755         } else {
5756                 if (ut_params->obuf)
5757                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
5758                                         ciphertext_len, buffer);
5759                 else
5760                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
5761                                         ciphertext_len, buffer);
5762
5763                 debug_hexdump(stdout, "ciphertext:", ciphertext,
5764                         ciphertext_len);
5765                 debug_hexdump(stdout, "ciphertext expected:",
5766                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
5767
5768                 if (ut_params->obuf)
5769                         digest = rte_pktmbuf_read(ut_params->obuf,
5770                                 (tdata->digest.offset_bytes == 0 ?
5771                                 plaintext_pad_len : tdata->digest.offset_bytes),
5772                                 tdata->digest.len, digest_buffer);
5773                 else
5774                         digest = rte_pktmbuf_read(ut_params->ibuf,
5775                                 (tdata->digest.offset_bytes == 0 ?
5776                                 plaintext_pad_len : tdata->digest.offset_bytes),
5777                                 tdata->digest.len, digest_buffer);
5778
5779                 debug_hexdump(stdout, "digest:", digest,
5780                         tdata->digest.len);
5781                 debug_hexdump(stdout, "digest expected:",
5782                         tdata->digest.data, tdata->digest.len);
5783         }
5784
5785         /* Validate obuf */
5786         if (verify) {
5787                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5788                         plaintext,
5789                         tdata->plaintext.data,
5790                         tdata->plaintext.len >> 3,
5791                         "KASUMI Plaintext data not as expected");
5792         } else {
5793                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5794                         ciphertext,
5795                         tdata->ciphertext.data,
5796                         tdata->validDataLenInBits.len,
5797                         "KASUMI Ciphertext data not as expected");
5798
5799                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
5800                         digest,
5801                         tdata->digest.data,
5802                         DIGEST_BYTE_LENGTH_KASUMI_F9,
5803                         "KASUMI Generated auth tag not as expected");
5804         }
5805         return 0;
5806 }
5807
5808 static int
5809 test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
5810 {
5811         struct crypto_testsuite_params *ts_params = &testsuite_params;
5812         struct crypto_unittest_params *ut_params = &unittest_params;
5813
5814         int retval;
5815
5816         uint8_t *plaintext, *ciphertext;
5817         unsigned plaintext_pad_len;
5818         unsigned plaintext_len;
5819         struct rte_cryptodev_info dev_info;
5820
5821         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5822         uint64_t feat_flags = dev_info.feature_flags;
5823
5824         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5825                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5826                 printf("Device doesn't support RAW data-path APIs.\n");
5827                 return TEST_SKIPPED;
5828         }
5829
5830         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
5831                 return TEST_SKIPPED;
5832
5833         /* Verify the capabilities */
5834         struct rte_cryptodev_sym_capability_idx cap_idx;
5835         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5836         cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
5837         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5838                         &cap_idx) == NULL)
5839                 return TEST_SKIPPED;
5840         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5841         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
5842         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5843                         &cap_idx) == NULL)
5844                 return TEST_SKIPPED;
5845
5846         /* Create KASUMI session */
5847         retval = create_wireless_algo_cipher_auth_session(
5848                         ts_params->valid_devs[0],
5849                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
5850                         RTE_CRYPTO_AUTH_OP_GENERATE,
5851                         RTE_CRYPTO_AUTH_KASUMI_F9,
5852                         RTE_CRYPTO_CIPHER_KASUMI_F8,
5853                         tdata->key.data, tdata->key.len,
5854                         0, tdata->digest.len,
5855                         tdata->cipher_iv.len);
5856         if (retval != 0)
5857                 return retval;
5858
5859         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
5860
5861         /* clear mbuf payload */
5862         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
5863                         rte_pktmbuf_tailroom(ut_params->ibuf));
5864
5865         plaintext_len = ceil_byte_length(tdata->plaintext.len);
5866         /* Append data which is padded to a multiple of */
5867         /* the algorithms block size */
5868         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
5869         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
5870                                 plaintext_pad_len);
5871         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
5872
5873         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
5874
5875         /* Create KASUMI operation */
5876         retval = create_wireless_algo_cipher_hash_operation(tdata->digest.data,
5877                                 tdata->digest.len, NULL, 0,
5878                                 plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
5879                                 tdata->cipher_iv.data, tdata->cipher_iv.len,
5880                                 RTE_ALIGN_CEIL(tdata->validCipherLenInBits.len, 8),
5881                                 tdata->validCipherOffsetInBits.len,
5882                                 tdata->validAuthLenInBits.len,
5883                                 0
5884                                 );
5885         if (retval < 0)
5886                 return retval;
5887
5888         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
5889                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
5890                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
5891         else
5892                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
5893                         ut_params->op);
5894         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
5895
5896         if (ut_params->op->sym->m_dst)
5897                 ut_params->obuf = ut_params->op->sym->m_dst;
5898         else
5899                 ut_params->obuf = ut_params->op->sym->m_src;
5900
5901         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
5902                                 tdata->validCipherOffsetInBits.len >> 3);
5903
5904         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
5905                         + plaintext_pad_len;
5906
5907         const uint8_t *reference_ciphertext = tdata->ciphertext.data +
5908                                 (tdata->validCipherOffsetInBits.len >> 3);
5909         /* Validate obuf */
5910         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
5911                 ciphertext,
5912                 reference_ciphertext,
5913                 tdata->validCipherLenInBits.len,
5914                 "KASUMI Ciphertext data not as expected");
5915
5916         /* Validate obuf */
5917         TEST_ASSERT_BUFFERS_ARE_EQUAL(
5918                 ut_params->digest,
5919                 tdata->digest.data,
5920                 DIGEST_BYTE_LENGTH_SNOW3G_UIA2,
5921                 "KASUMI Generated auth tag not as expected");
5922         return 0;
5923 }
5924
5925 static int
5926 check_cipher_capability(const struct crypto_testsuite_params *ts_params,
5927                         const enum rte_crypto_cipher_algorithm cipher_algo,
5928                         const uint16_t key_size, const uint16_t iv_size)
5929 {
5930         struct rte_cryptodev_sym_capability_idx cap_idx;
5931         const struct rte_cryptodev_symmetric_capability *cap;
5932
5933         /* Check if device supports the algorithm */
5934         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
5935         cap_idx.algo.cipher = cipher_algo;
5936
5937         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5938                         &cap_idx);
5939
5940         if (cap == NULL)
5941                 return -1;
5942
5943         /* Check if device supports key size and IV size */
5944         if (rte_cryptodev_sym_capability_check_cipher(cap, key_size,
5945                         iv_size) < 0) {
5946                 return -1;
5947         }
5948
5949         return 0;
5950 }
5951
5952 static int
5953 check_auth_capability(const struct crypto_testsuite_params *ts_params,
5954                         const enum rte_crypto_auth_algorithm auth_algo,
5955                         const uint16_t key_size, const uint16_t iv_size,
5956                         const uint16_t tag_size)
5957 {
5958         struct rte_cryptodev_sym_capability_idx cap_idx;
5959         const struct rte_cryptodev_symmetric_capability *cap;
5960
5961         /* Check if device supports the algorithm */
5962         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
5963         cap_idx.algo.auth = auth_algo;
5964
5965         cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
5966                         &cap_idx);
5967
5968         if (cap == NULL)
5969                 return -1;
5970
5971         /* Check if device supports key size and IV size */
5972         if (rte_cryptodev_sym_capability_check_auth(cap, key_size,
5973                         tag_size, iv_size) < 0) {
5974                 return -1;
5975         }
5976
5977         return 0;
5978 }
5979
5980 static int
5981 test_zuc_encryption(const struct wireless_test_data *tdata)
5982 {
5983         struct crypto_testsuite_params *ts_params = &testsuite_params;
5984         struct crypto_unittest_params *ut_params = &unittest_params;
5985
5986         int retval;
5987         uint8_t *plaintext, *ciphertext;
5988         unsigned plaintext_pad_len;
5989         unsigned plaintext_len;
5990         struct rte_cryptodev_info dev_info;
5991
5992         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
5993         uint64_t feat_flags = dev_info.feature_flags;
5994
5995         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
5996                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
5997                 printf("Device doesn't support RAW data-path APIs.\n");
5998                 return TEST_SKIPPED;
5999         }
6000
6001         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6002                 return TEST_SKIPPED;
6003
6004         /* Check if device supports ZUC EEA3 */
6005         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6006                         tdata->key.len, tdata->cipher_iv.len) < 0)
6007                 return TEST_SKIPPED;
6008
6009         /* Create ZUC session */
6010         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6011                                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6012                                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6013                                         tdata->key.data, tdata->key.len,
6014                                         tdata->cipher_iv.len);
6015         if (retval != 0)
6016                 return retval;
6017
6018         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6019
6020         /* Clear mbuf payload */
6021         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6022                rte_pktmbuf_tailroom(ut_params->ibuf));
6023
6024         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6025         /* Append data which is padded to a multiple */
6026         /* of the algorithms block size */
6027         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6028         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6029                                 plaintext_pad_len);
6030         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6031
6032         debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
6033
6034         /* Create ZUC operation */
6035         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6036                                         tdata->cipher_iv.len,
6037                                         tdata->plaintext.len,
6038                                         0);
6039         if (retval < 0)
6040                 return retval;
6041
6042         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6043                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6044                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6045         else
6046                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6047                                                 ut_params->op);
6048         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6049
6050         ut_params->obuf = ut_params->op->sym->m_dst;
6051         if (ut_params->obuf)
6052                 ciphertext = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *);
6053         else
6054                 ciphertext = plaintext;
6055
6056         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6057
6058         /* Validate obuf */
6059         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6060                 ciphertext,
6061                 tdata->ciphertext.data,
6062                 tdata->validCipherLenInBits.len,
6063                 "ZUC Ciphertext data not as expected");
6064         return 0;
6065 }
6066
6067 static int
6068 test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
6069 {
6070         struct crypto_testsuite_params *ts_params = &testsuite_params;
6071         struct crypto_unittest_params *ut_params = &unittest_params;
6072
6073         int retval;
6074
6075         unsigned int plaintext_pad_len;
6076         unsigned int plaintext_len;
6077         const uint8_t *ciphertext;
6078         uint8_t ciphertext_buffer[2048];
6079         struct rte_cryptodev_info dev_info;
6080
6081         /* Check if device supports ZUC EEA3 */
6082         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6083                         tdata->key.len, tdata->cipher_iv.len) < 0)
6084                 return TEST_SKIPPED;
6085
6086         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6087                 return TEST_SKIPPED;
6088
6089         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6090
6091         uint64_t feat_flags = dev_info.feature_flags;
6092
6093         if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6094                 printf("Device doesn't support in-place scatter-gather. "
6095                                 "Test Skipped.\n");
6096                 return TEST_SKIPPED;
6097         }
6098
6099         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6100                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6101                 printf("Device doesn't support RAW data-path APIs.\n");
6102                 return TEST_SKIPPED;
6103         }
6104
6105         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6106
6107         /* Append data which is padded to a multiple */
6108         /* of the algorithms block size */
6109         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6110
6111         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6112                         plaintext_pad_len, 10, 0);
6113
6114         pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6115                         tdata->plaintext.data);
6116
6117         /* Create ZUC session */
6118         retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
6119                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
6120                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6121                         tdata->key.data, tdata->key.len,
6122                         tdata->cipher_iv.len);
6123         if (retval < 0)
6124                 return retval;
6125
6126         /* Clear mbuf payload */
6127
6128         pktmbuf_write(ut_params->ibuf, 0, plaintext_len, tdata->plaintext.data);
6129
6130         /* Create ZUC operation */
6131         retval = create_wireless_algo_cipher_operation(tdata->cipher_iv.data,
6132                         tdata->cipher_iv.len, tdata->plaintext.len,
6133                         0);
6134         if (retval < 0)
6135                 return retval;
6136
6137         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6138                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6139                                 ut_params->op, 1, 0, 1, tdata->cipher_iv.len);
6140         else
6141                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6142                                                 ut_params->op);
6143         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6144
6145         ut_params->obuf = ut_params->op->sym->m_dst;
6146         if (ut_params->obuf)
6147                 ciphertext = rte_pktmbuf_read(ut_params->obuf,
6148                         0, plaintext_len, ciphertext_buffer);
6149         else
6150                 ciphertext = rte_pktmbuf_read(ut_params->ibuf,
6151                         0, plaintext_len, ciphertext_buffer);
6152
6153         /* Validate obuf */
6154         debug_hexdump(stdout, "ciphertext:", ciphertext, plaintext_len);
6155
6156         /* Validate obuf */
6157         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6158                 ciphertext,
6159                 tdata->ciphertext.data,
6160                 tdata->validCipherLenInBits.len,
6161                 "ZUC Ciphertext data not as expected");
6162
6163         return 0;
6164 }
6165
6166 static int
6167 test_zuc_authentication(const struct wireless_test_data *tdata)
6168 {
6169         struct crypto_testsuite_params *ts_params = &testsuite_params;
6170         struct crypto_unittest_params *ut_params = &unittest_params;
6171
6172         int retval;
6173         unsigned plaintext_pad_len;
6174         unsigned plaintext_len;
6175         uint8_t *plaintext;
6176
6177         struct rte_cryptodev_info dev_info;
6178
6179         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6180         uint64_t feat_flags = dev_info.feature_flags;
6181
6182         if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
6183                         (tdata->validAuthLenInBits.len % 8 != 0)) {
6184                 printf("Device doesn't support NON-Byte Aligned Data.\n");
6185                 return TEST_SKIPPED;
6186         }
6187
6188         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6189                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6190                 printf("Device doesn't support RAW data-path APIs.\n");
6191                 return TEST_SKIPPED;
6192         }
6193
6194         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
6195                 return TEST_SKIPPED;
6196
6197         /* Check if device supports ZUC EIA3 */
6198         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6199                         tdata->key.len, tdata->auth_iv.len,
6200                         tdata->digest.len) < 0)
6201                 return TEST_SKIPPED;
6202
6203         /* Create ZUC session */
6204         retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
6205                         tdata->key.data, tdata->key.len,
6206                         tdata->auth_iv.len, tdata->digest.len,
6207                         RTE_CRYPTO_AUTH_OP_GENERATE,
6208                         RTE_CRYPTO_AUTH_ZUC_EIA3);
6209         if (retval != 0)
6210                 return retval;
6211
6212         /* alloc mbuf and set payload */
6213         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6214
6215         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6216         rte_pktmbuf_tailroom(ut_params->ibuf));
6217
6218         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6219         /* Append data which is padded to a multiple of */
6220         /* the algorithms block size */
6221         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 8);
6222         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6223                                 plaintext_pad_len);
6224         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6225
6226         /* Create ZUC operation */
6227         retval = create_wireless_algo_hash_operation(NULL, tdata->digest.len,
6228                         tdata->auth_iv.data, tdata->auth_iv.len,
6229                         plaintext_pad_len, RTE_CRYPTO_AUTH_OP_GENERATE,
6230                         tdata->validAuthLenInBits.len,
6231                         0);
6232         if (retval < 0)
6233                 return retval;
6234
6235         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6236                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6237                                 ut_params->op, 0, 1, 1, 0);
6238         else
6239                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6240                                 ut_params->op);
6241         ut_params->obuf = ut_params->op->sym->m_src;
6242         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6243         ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
6244                         + plaintext_pad_len;
6245
6246         /* Validate obuf */
6247         TEST_ASSERT_BUFFERS_ARE_EQUAL(
6248         ut_params->digest,
6249         tdata->digest.data,
6250         tdata->digest.len,
6251         "ZUC Generated auth tag not as expected");
6252
6253         return 0;
6254 }
6255
6256 static int
6257 test_zuc_auth_cipher(const struct wireless_test_data *tdata,
6258         uint8_t op_mode, uint8_t verify)
6259 {
6260         struct crypto_testsuite_params *ts_params = &testsuite_params;
6261         struct crypto_unittest_params *ut_params = &unittest_params;
6262
6263         int retval;
6264
6265         uint8_t *plaintext = NULL, *ciphertext = NULL;
6266         unsigned int plaintext_pad_len;
6267         unsigned int plaintext_len;
6268         unsigned int ciphertext_pad_len;
6269         unsigned int ciphertext_len;
6270
6271         struct rte_cryptodev_info dev_info;
6272
6273         /* Check if device supports ZUC EEA3 */
6274         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6275                         tdata->key.len, tdata->cipher_iv.len) < 0)
6276                 return TEST_SKIPPED;
6277
6278         /* Check if device supports ZUC EIA3 */
6279         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6280                         tdata->key.len, tdata->auth_iv.len,
6281                         tdata->digest.len) < 0)
6282                 return TEST_SKIPPED;
6283
6284         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6285
6286         uint64_t feat_flags = dev_info.feature_flags;
6287
6288         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6289                 printf("Device doesn't support digest encrypted.\n");
6290                 return TEST_SKIPPED;
6291         }
6292         if (op_mode == IN_PLACE) {
6293                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6294                         printf("Device doesn't support in-place scatter-gather "
6295                                         "in both input and output mbufs.\n");
6296                         return TEST_SKIPPED;
6297                 }
6298
6299                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6300                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6301                         printf("Device doesn't support RAW data-path APIs.\n");
6302                         return TEST_SKIPPED;
6303                 }
6304         } else {
6305                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6306                         return TEST_SKIPPED;
6307                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6308                         printf("Device doesn't support out-of-place scatter-gather "
6309                                         "in both input and output mbufs.\n");
6310                         return TEST_SKIPPED;
6311                 }
6312         }
6313
6314         /* Create ZUC session */
6315         retval = create_wireless_algo_auth_cipher_session(
6316                         ts_params->valid_devs[0],
6317                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6318                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6319                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6320                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6321                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6322                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6323                         tdata->key.data, tdata->key.len,
6324                         tdata->auth_iv.len, tdata->digest.len,
6325                         tdata->cipher_iv.len);
6326
6327         if (retval != 0)
6328                 return retval;
6329
6330         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6331         if (op_mode == OUT_OF_PLACE)
6332                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
6333
6334         /* clear mbuf payload */
6335         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
6336                 rte_pktmbuf_tailroom(ut_params->ibuf));
6337         if (op_mode == OUT_OF_PLACE)
6338                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
6339                         rte_pktmbuf_tailroom(ut_params->obuf));
6340
6341         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6342         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6343         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6344         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6345
6346         if (verify) {
6347                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6348                                         ciphertext_pad_len);
6349                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
6350                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6351                         ciphertext_len);
6352         } else {
6353                 /* make sure enough space to cover partial digest verify case */
6354                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
6355                                         ciphertext_pad_len);
6356                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
6357                 debug_hexdump(stdout, "plaintext:", plaintext,
6358                         plaintext_len);
6359         }
6360
6361         if (op_mode == OUT_OF_PLACE)
6362                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
6363
6364         /* Create ZUC operation */
6365         retval = create_wireless_algo_auth_cipher_operation(
6366                 tdata->digest.data, tdata->digest.len,
6367                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6368                 tdata->auth_iv.data, tdata->auth_iv.len,
6369                 (tdata->digest.offset_bytes == 0 ?
6370                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6371                         : tdata->digest.offset_bytes),
6372                 tdata->validCipherLenInBits.len,
6373                 tdata->validCipherOffsetInBits.len,
6374                 tdata->validAuthLenInBits.len,
6375                 0,
6376                 op_mode, 0, verify);
6377
6378         if (retval < 0)
6379                 return retval;
6380
6381         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6382                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6383                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6384         else
6385                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6386                         ut_params->op);
6387
6388         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6389
6390         ut_params->obuf = (op_mode == IN_PLACE ?
6391                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6392
6393
6394         if (verify) {
6395                 if (ut_params->obuf)
6396                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
6397                                                         uint8_t *);
6398                 else
6399                         plaintext = ciphertext;
6400
6401                 debug_hexdump(stdout, "plaintext:", plaintext,
6402                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6403                 debug_hexdump(stdout, "plaintext expected:",
6404                         tdata->plaintext.data,
6405                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6406         } else {
6407                 if (ut_params->obuf)
6408                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
6409                                                         uint8_t *);
6410                 else
6411                         ciphertext = plaintext;
6412
6413                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6414                         ciphertext_len);
6415                 debug_hexdump(stdout, "ciphertext expected:",
6416                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6417
6418                 ut_params->digest = rte_pktmbuf_mtod(
6419                         ut_params->obuf, uint8_t *) +
6420                         (tdata->digest.offset_bytes == 0 ?
6421                         plaintext_pad_len : tdata->digest.offset_bytes);
6422
6423                 debug_hexdump(stdout, "digest:", ut_params->digest,
6424                         tdata->digest.len);
6425                 debug_hexdump(stdout, "digest expected:",
6426                         tdata->digest.data, tdata->digest.len);
6427         }
6428
6429         /* Validate obuf */
6430         if (verify) {
6431                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6432                         plaintext,
6433                         tdata->plaintext.data,
6434                         tdata->plaintext.len >> 3,
6435                         "ZUC Plaintext data not as expected");
6436         } else {
6437                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6438                         ciphertext,
6439                         tdata->ciphertext.data,
6440                         tdata->ciphertext.len >> 3,
6441                         "ZUC Ciphertext data not as expected");
6442
6443                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6444                         ut_params->digest,
6445                         tdata->digest.data,
6446                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6447                         "ZUC Generated auth tag not as expected");
6448         }
6449         return 0;
6450 }
6451
6452 static int
6453 test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata,
6454         uint8_t op_mode, uint8_t verify)
6455 {
6456         struct crypto_testsuite_params *ts_params = &testsuite_params;
6457         struct crypto_unittest_params *ut_params = &unittest_params;
6458
6459         int retval;
6460
6461         const uint8_t *plaintext = NULL;
6462         const uint8_t *ciphertext = NULL;
6463         const uint8_t *digest = NULL;
6464         unsigned int plaintext_pad_len;
6465         unsigned int plaintext_len;
6466         unsigned int ciphertext_pad_len;
6467         unsigned int ciphertext_len;
6468         uint8_t buffer[10000];
6469         uint8_t digest_buffer[10000];
6470
6471         struct rte_cryptodev_info dev_info;
6472
6473         /* Check if device supports ZUC EEA3 */
6474         if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3,
6475                         tdata->key.len, tdata->cipher_iv.len) < 0)
6476                 return TEST_SKIPPED;
6477
6478         /* Check if device supports ZUC EIA3 */
6479         if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3,
6480                         tdata->key.len, tdata->auth_iv.len,
6481                         tdata->digest.len) < 0)
6482                 return TEST_SKIPPED;
6483
6484         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6485
6486         uint64_t feat_flags = dev_info.feature_flags;
6487
6488         if (op_mode == IN_PLACE) {
6489                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
6490                         printf("Device doesn't support in-place scatter-gather "
6491                                         "in both input and output mbufs.\n");
6492                         return TEST_SKIPPED;
6493                 }
6494
6495                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
6496                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
6497                         printf("Device doesn't support RAW data-path APIs.\n");
6498                         return TEST_SKIPPED;
6499                 }
6500         } else {
6501                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6502                         return TEST_SKIPPED;
6503                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
6504                         printf("Device doesn't support out-of-place scatter-gather "
6505                                         "in both input and output mbufs.\n");
6506                         return TEST_SKIPPED;
6507                 }
6508                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6509                         printf("Device doesn't support digest encrypted.\n");
6510                         return TEST_SKIPPED;
6511                 }
6512         }
6513
6514         /* Create ZUC session */
6515         retval = create_wireless_algo_auth_cipher_session(
6516                         ts_params->valid_devs[0],
6517                         (verify ? RTE_CRYPTO_CIPHER_OP_DECRYPT
6518                                         : RTE_CRYPTO_CIPHER_OP_ENCRYPT),
6519                         (verify ? RTE_CRYPTO_AUTH_OP_VERIFY
6520                                         : RTE_CRYPTO_AUTH_OP_GENERATE),
6521                         RTE_CRYPTO_AUTH_ZUC_EIA3,
6522                         RTE_CRYPTO_CIPHER_ZUC_EEA3,
6523                         tdata->key.data, tdata->key.len,
6524                         tdata->auth_iv.len, tdata->digest.len,
6525                         tdata->cipher_iv.len);
6526
6527         if (retval != 0)
6528                 return retval;
6529
6530         ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
6531         plaintext_len = ceil_byte_length(tdata->plaintext.len);
6532         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
6533         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
6534
6535         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
6536                         plaintext_pad_len, 15, 0);
6537         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
6538                         "Failed to allocate input buffer in mempool");
6539
6540         if (op_mode == OUT_OF_PLACE) {
6541                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
6542                                 plaintext_pad_len, 15, 0);
6543                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
6544                                 "Failed to allocate output buffer in mempool");
6545         }
6546
6547         if (verify) {
6548                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
6549                         tdata->ciphertext.data);
6550                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6551                                         ciphertext_len, buffer);
6552                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6553                         ciphertext_len);
6554         } else {
6555                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
6556                         tdata->plaintext.data);
6557                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6558                                         plaintext_len, buffer);
6559                 debug_hexdump(stdout, "plaintext:", plaintext,
6560                         plaintext_len);
6561         }
6562         memset(buffer, 0, sizeof(buffer));
6563
6564         /* Create ZUC operation */
6565         retval = create_wireless_algo_auth_cipher_operation(
6566                 tdata->digest.data, tdata->digest.len,
6567                 tdata->cipher_iv.data, tdata->cipher_iv.len,
6568                 NULL, 0,
6569                 (tdata->digest.offset_bytes == 0 ?
6570                 (verify ? ciphertext_pad_len : plaintext_pad_len)
6571                         : tdata->digest.offset_bytes),
6572                 tdata->validCipherLenInBits.len,
6573                 tdata->validCipherOffsetInBits.len,
6574                 tdata->validAuthLenInBits.len,
6575                 0,
6576                 op_mode, 1, verify);
6577
6578         if (retval < 0)
6579                 return retval;
6580
6581         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6582                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
6583                                 ut_params->op, 1, 1, 1, tdata->cipher_iv.len);
6584         else
6585                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
6586                         ut_params->op);
6587
6588         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
6589
6590         ut_params->obuf = (op_mode == IN_PLACE ?
6591                 ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
6592
6593         if (verify) {
6594                 if (ut_params->obuf)
6595                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
6596                                         plaintext_len, buffer);
6597                 else
6598                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
6599                                         plaintext_len, buffer);
6600
6601                 debug_hexdump(stdout, "plaintext:", plaintext,
6602                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6603                 debug_hexdump(stdout, "plaintext expected:",
6604                         tdata->plaintext.data,
6605                         (tdata->plaintext.len >> 3) - tdata->digest.len);
6606         } else {
6607                 if (ut_params->obuf)
6608                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
6609                                         ciphertext_len, buffer);
6610                 else
6611                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
6612                                         ciphertext_len, buffer);
6613
6614                 debug_hexdump(stdout, "ciphertext:", ciphertext,
6615                         ciphertext_len);
6616                 debug_hexdump(stdout, "ciphertext expected:",
6617                         tdata->ciphertext.data, tdata->ciphertext.len >> 3);
6618
6619                 if (ut_params->obuf)
6620                         digest = rte_pktmbuf_read(ut_params->obuf,
6621                                 (tdata->digest.offset_bytes == 0 ?
6622                                 plaintext_pad_len : tdata->digest.offset_bytes),
6623                                 tdata->digest.len, digest_buffer);
6624                 else
6625                         digest = rte_pktmbuf_read(ut_params->ibuf,
6626                                 (tdata->digest.offset_bytes == 0 ?
6627                                 plaintext_pad_len : tdata->digest.offset_bytes),
6628                                 tdata->digest.len, digest_buffer);
6629
6630                 debug_hexdump(stdout, "digest:", digest,
6631                         tdata->digest.len);
6632                 debug_hexdump(stdout, "digest expected:",
6633                         tdata->digest.data, tdata->digest.len);
6634         }
6635
6636         /* Validate obuf */
6637         if (verify) {
6638                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6639                         plaintext,
6640                         tdata->plaintext.data,
6641                         tdata->plaintext.len >> 3,
6642                         "ZUC Plaintext data not as expected");
6643         } else {
6644                 TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
6645                         ciphertext,
6646                         tdata->ciphertext.data,
6647                         tdata->validDataLenInBits.len,
6648                         "ZUC Ciphertext data not as expected");
6649
6650                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
6651                         digest,
6652                         tdata->digest.data,
6653                         DIGEST_BYTE_LENGTH_KASUMI_F9,
6654                         "ZUC Generated auth tag not as expected");
6655         }
6656         return 0;
6657 }
6658
6659 static int
6660 test_kasumi_encryption_test_case_1(void)
6661 {
6662         return test_kasumi_encryption(&kasumi_test_case_1);
6663 }
6664
6665 static int
6666 test_kasumi_encryption_test_case_1_sgl(void)
6667 {
6668         return test_kasumi_encryption_sgl(&kasumi_test_case_1);
6669 }
6670
6671 static int
6672 test_kasumi_encryption_test_case_1_oop(void)
6673 {
6674         return test_kasumi_encryption_oop(&kasumi_test_case_1);
6675 }
6676
6677 static int
6678 test_kasumi_encryption_test_case_1_oop_sgl(void)
6679 {
6680         return test_kasumi_encryption_oop_sgl(&kasumi_test_case_1);
6681 }
6682
6683 static int
6684 test_kasumi_encryption_test_case_2(void)
6685 {
6686         return test_kasumi_encryption(&kasumi_test_case_2);
6687 }
6688
6689 static int
6690 test_kasumi_encryption_test_case_3(void)
6691 {
6692         return test_kasumi_encryption(&kasumi_test_case_3);
6693 }
6694
6695 static int
6696 test_kasumi_encryption_test_case_4(void)
6697 {
6698         return test_kasumi_encryption(&kasumi_test_case_4);
6699 }
6700
6701 static int
6702 test_kasumi_encryption_test_case_5(void)
6703 {
6704         return test_kasumi_encryption(&kasumi_test_case_5);
6705 }
6706
6707 static int
6708 test_kasumi_decryption_test_case_1(void)
6709 {
6710         return test_kasumi_decryption(&kasumi_test_case_1);
6711 }
6712
6713 static int
6714 test_kasumi_decryption_test_case_1_oop(void)
6715 {
6716         return test_kasumi_decryption_oop(&kasumi_test_case_1);
6717 }
6718
6719 static int
6720 test_kasumi_decryption_test_case_2(void)
6721 {
6722         return test_kasumi_decryption(&kasumi_test_case_2);
6723 }
6724
6725 static int
6726 test_kasumi_decryption_test_case_3(void)
6727 {
6728         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6729         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6730                 return TEST_SKIPPED;
6731         return test_kasumi_decryption(&kasumi_test_case_3);
6732 }
6733
6734 static int
6735 test_kasumi_decryption_test_case_4(void)
6736 {
6737         return test_kasumi_decryption(&kasumi_test_case_4);
6738 }
6739
6740 static int
6741 test_kasumi_decryption_test_case_5(void)
6742 {
6743         return test_kasumi_decryption(&kasumi_test_case_5);
6744 }
6745 static int
6746 test_snow3g_encryption_test_case_1(void)
6747 {
6748         return test_snow3g_encryption(&snow3g_test_case_1);
6749 }
6750
6751 static int
6752 test_snow3g_encryption_test_case_1_oop(void)
6753 {
6754         return test_snow3g_encryption_oop(&snow3g_test_case_1);
6755 }
6756
6757 static int
6758 test_snow3g_encryption_test_case_1_oop_sgl(void)
6759 {
6760         return test_snow3g_encryption_oop_sgl(&snow3g_test_case_1);
6761 }
6762
6763
6764 static int
6765 test_snow3g_encryption_test_case_1_offset_oop(void)
6766 {
6767         return test_snow3g_encryption_offset_oop(&snow3g_test_case_1);
6768 }
6769
6770 static int
6771 test_snow3g_encryption_test_case_2(void)
6772 {
6773         return test_snow3g_encryption(&snow3g_test_case_2);
6774 }
6775
6776 static int
6777 test_snow3g_encryption_test_case_3(void)
6778 {
6779         return test_snow3g_encryption(&snow3g_test_case_3);
6780 }
6781
6782 static int
6783 test_snow3g_encryption_test_case_4(void)
6784 {
6785         return test_snow3g_encryption(&snow3g_test_case_4);
6786 }
6787
6788 static int
6789 test_snow3g_encryption_test_case_5(void)
6790 {
6791         return test_snow3g_encryption(&snow3g_test_case_5);
6792 }
6793
6794 static int
6795 test_snow3g_decryption_test_case_1(void)
6796 {
6797         return test_snow3g_decryption(&snow3g_test_case_1);
6798 }
6799
6800 static int
6801 test_snow3g_decryption_test_case_1_oop(void)
6802 {
6803         return test_snow3g_decryption_oop(&snow3g_test_case_1);
6804 }
6805
6806 static int
6807 test_snow3g_decryption_test_case_2(void)
6808 {
6809         return test_snow3g_decryption(&snow3g_test_case_2);
6810 }
6811
6812 static int
6813 test_snow3g_decryption_test_case_3(void)
6814 {
6815         return test_snow3g_decryption(&snow3g_test_case_3);
6816 }
6817
6818 static int
6819 test_snow3g_decryption_test_case_4(void)
6820 {
6821         return test_snow3g_decryption(&snow3g_test_case_4);
6822 }
6823
6824 static int
6825 test_snow3g_decryption_test_case_5(void)
6826 {
6827         return test_snow3g_decryption(&snow3g_test_case_5);
6828 }
6829
6830 /*
6831  * Function prepares snow3g_hash_test_data from snow3g_test_data.
6832  * Pattern digest from snow3g_test_data must be allocated as
6833  * 4 last bytes in plaintext.
6834  */
6835 static void
6836 snow3g_hash_test_vector_setup(const struct snow3g_test_data *pattern,
6837                 struct snow3g_hash_test_data *output)
6838 {
6839         if ((pattern != NULL) && (output != NULL)) {
6840                 output->key.len = pattern->key.len;
6841
6842                 memcpy(output->key.data,
6843                 pattern->key.data, pattern->key.len);
6844
6845                 output->auth_iv.len = pattern->auth_iv.len;
6846
6847                 memcpy(output->auth_iv.data,
6848                 pattern->auth_iv.data, pattern->auth_iv.len);
6849
6850                 output->plaintext.len = pattern->plaintext.len;
6851
6852                 memcpy(output->plaintext.data,
6853                 pattern->plaintext.data, pattern->plaintext.len >> 3);
6854
6855                 output->digest.len = pattern->digest.len;
6856
6857                 memcpy(output->digest.data,
6858                 &pattern->plaintext.data[pattern->digest.offset_bytes],
6859                 pattern->digest.len);
6860
6861                 output->validAuthLenInBits.len =
6862                 pattern->validAuthLenInBits.len;
6863         }
6864 }
6865
6866 /*
6867  * Test case verify computed cipher and digest from snow3g_test_case_7 data.
6868  */
6869 static int
6870 test_snow3g_decryption_with_digest_test_case_1(void)
6871 {
6872         struct snow3g_hash_test_data snow3g_hash_data;
6873         struct rte_cryptodev_info dev_info;
6874         struct crypto_testsuite_params *ts_params = &testsuite_params;
6875
6876         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
6877         uint64_t feat_flags = dev_info.feature_flags;
6878
6879         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
6880                 printf("Device doesn't support encrypted digest operations.\n");
6881                 return TEST_SKIPPED;
6882         }
6883
6884         /*
6885          * Function prepare data for hash verification test case.
6886          * Digest is allocated in 4 last bytes in plaintext, pattern.
6887          */
6888         snow3g_hash_test_vector_setup(&snow3g_test_case_7, &snow3g_hash_data);
6889
6890         return test_snow3g_decryption(&snow3g_test_case_7) &
6891                         test_snow3g_authentication_verify(&snow3g_hash_data);
6892 }
6893
6894 static int
6895 test_snow3g_cipher_auth_test_case_1(void)
6896 {
6897         return test_snow3g_cipher_auth(&snow3g_test_case_3);
6898 }
6899
6900 static int
6901 test_snow3g_auth_cipher_test_case_1(void)
6902 {
6903         return test_snow3g_auth_cipher(
6904                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 0);
6905 }
6906
6907 static int
6908 test_snow3g_auth_cipher_test_case_2(void)
6909 {
6910         return test_snow3g_auth_cipher(
6911                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 0);
6912 }
6913
6914 static int
6915 test_snow3g_auth_cipher_test_case_2_oop(void)
6916 {
6917         return test_snow3g_auth_cipher(
6918                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
6919 }
6920
6921 static int
6922 test_snow3g_auth_cipher_part_digest_enc(void)
6923 {
6924         return test_snow3g_auth_cipher(
6925                 &snow3g_auth_cipher_partial_digest_encryption,
6926                         IN_PLACE, 0);
6927 }
6928
6929 static int
6930 test_snow3g_auth_cipher_part_digest_enc_oop(void)
6931 {
6932         return test_snow3g_auth_cipher(
6933                 &snow3g_auth_cipher_partial_digest_encryption,
6934                         OUT_OF_PLACE, 0);
6935 }
6936
6937 static int
6938 test_snow3g_auth_cipher_test_case_3_sgl(void)
6939 {
6940         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6941         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6942                 return TEST_SKIPPED;
6943         return test_snow3g_auth_cipher_sgl(
6944                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
6945 }
6946
6947 static int
6948 test_snow3g_auth_cipher_test_case_3_oop_sgl(void)
6949 {
6950         return test_snow3g_auth_cipher_sgl(
6951                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 0);
6952 }
6953
6954 static int
6955 test_snow3g_auth_cipher_part_digest_enc_sgl(void)
6956 {
6957         /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
6958         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
6959                 return TEST_SKIPPED;
6960         return test_snow3g_auth_cipher_sgl(
6961                 &snow3g_auth_cipher_partial_digest_encryption,
6962                         IN_PLACE, 0);
6963 }
6964
6965 static int
6966 test_snow3g_auth_cipher_part_digest_enc_oop_sgl(void)
6967 {
6968         return test_snow3g_auth_cipher_sgl(
6969                 &snow3g_auth_cipher_partial_digest_encryption,
6970                         OUT_OF_PLACE, 0);
6971 }
6972
6973 static int
6974 test_snow3g_auth_cipher_verify_test_case_1(void)
6975 {
6976         return test_snow3g_auth_cipher(
6977                 &snow3g_auth_cipher_test_case_1, IN_PLACE, 1);
6978 }
6979
6980 static int
6981 test_snow3g_auth_cipher_verify_test_case_2(void)
6982 {
6983         return test_snow3g_auth_cipher(
6984                 &snow3g_auth_cipher_test_case_2, IN_PLACE, 1);
6985 }
6986
6987 static int
6988 test_snow3g_auth_cipher_verify_test_case_2_oop(void)
6989 {
6990         return test_snow3g_auth_cipher(
6991                 &snow3g_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
6992 }
6993
6994 static int
6995 test_snow3g_auth_cipher_verify_part_digest_enc(void)
6996 {
6997         return test_snow3g_auth_cipher(
6998                 &snow3g_auth_cipher_partial_digest_encryption,
6999                         IN_PLACE, 1);
7000 }
7001
7002 static int
7003 test_snow3g_auth_cipher_verify_part_digest_enc_oop(void)
7004 {
7005         return test_snow3g_auth_cipher(
7006                 &snow3g_auth_cipher_partial_digest_encryption,
7007                         OUT_OF_PLACE, 1);
7008 }
7009
7010 static int
7011 test_snow3g_auth_cipher_verify_test_case_3_sgl(void)
7012 {
7013         return test_snow3g_auth_cipher_sgl(
7014                 &snow3g_auth_cipher_test_case_3, IN_PLACE, 1);
7015 }
7016
7017 static int
7018 test_snow3g_auth_cipher_verify_test_case_3_oop_sgl(void)
7019 {
7020         return test_snow3g_auth_cipher_sgl(
7021                 &snow3g_auth_cipher_test_case_3, OUT_OF_PLACE, 1);
7022 }
7023
7024 static int
7025 test_snow3g_auth_cipher_verify_part_digest_enc_sgl(void)
7026 {
7027         return test_snow3g_auth_cipher_sgl(
7028                 &snow3g_auth_cipher_partial_digest_encryption,
7029                         IN_PLACE, 1);
7030 }
7031
7032 static int
7033 test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl(void)
7034 {
7035         return test_snow3g_auth_cipher_sgl(
7036                 &snow3g_auth_cipher_partial_digest_encryption,
7037                         OUT_OF_PLACE, 1);
7038 }
7039
7040 static int
7041 test_snow3g_auth_cipher_with_digest_test_case_1(void)
7042 {
7043         return test_snow3g_auth_cipher(
7044                 &snow3g_test_case_7, IN_PLACE, 0);
7045 }
7046
7047 static int
7048 test_kasumi_auth_cipher_test_case_1(void)
7049 {
7050         return test_kasumi_auth_cipher(
7051                 &kasumi_test_case_3, IN_PLACE, 0);
7052 }
7053
7054 static int
7055 test_kasumi_auth_cipher_test_case_2(void)
7056 {
7057         return test_kasumi_auth_cipher(
7058                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7059 }
7060
7061 static int
7062 test_kasumi_auth_cipher_test_case_2_oop(void)
7063 {
7064         return test_kasumi_auth_cipher(
7065                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7066 }
7067
7068 static int
7069 test_kasumi_auth_cipher_test_case_2_sgl(void)
7070 {
7071         return test_kasumi_auth_cipher_sgl(
7072                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 0);
7073 }
7074
7075 static int
7076 test_kasumi_auth_cipher_test_case_2_oop_sgl(void)
7077 {
7078         return test_kasumi_auth_cipher_sgl(
7079                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 0);
7080 }
7081
7082 static int
7083 test_kasumi_auth_cipher_verify_test_case_1(void)
7084 {
7085         return test_kasumi_auth_cipher(
7086                 &kasumi_test_case_3, IN_PLACE, 1);
7087 }
7088
7089 static int
7090 test_kasumi_auth_cipher_verify_test_case_2(void)
7091 {
7092         return test_kasumi_auth_cipher(
7093                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7094 }
7095
7096 static int
7097 test_kasumi_auth_cipher_verify_test_case_2_oop(void)
7098 {
7099         return test_kasumi_auth_cipher(
7100                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7101 }
7102
7103 static int
7104 test_kasumi_auth_cipher_verify_test_case_2_sgl(void)
7105 {
7106         return test_kasumi_auth_cipher_sgl(
7107                 &kasumi_auth_cipher_test_case_2, IN_PLACE, 1);
7108 }
7109
7110 static int
7111 test_kasumi_auth_cipher_verify_test_case_2_oop_sgl(void)
7112 {
7113         return test_kasumi_auth_cipher_sgl(
7114                 &kasumi_auth_cipher_test_case_2, OUT_OF_PLACE, 1);
7115 }
7116
7117 static int
7118 test_kasumi_cipher_auth_test_case_1(void)
7119 {
7120         return test_kasumi_cipher_auth(&kasumi_test_case_6);
7121 }
7122
7123 static int
7124 test_zuc_encryption_test_case_1(void)
7125 {
7126         return test_zuc_encryption(&zuc_test_case_cipher_193b);
7127 }
7128
7129 static int
7130 test_zuc_encryption_test_case_2(void)
7131 {
7132         return test_zuc_encryption(&zuc_test_case_cipher_800b);
7133 }
7134
7135 static int
7136 test_zuc_encryption_test_case_3(void)
7137 {
7138         return test_zuc_encryption(&zuc_test_case_cipher_1570b);
7139 }
7140
7141 static int
7142 test_zuc_encryption_test_case_4(void)
7143 {
7144         return test_zuc_encryption(&zuc_test_case_cipher_2798b);
7145 }
7146
7147 static int
7148 test_zuc_encryption_test_case_5(void)
7149 {
7150         return test_zuc_encryption(&zuc_test_case_cipher_4019b);
7151 }
7152
7153 static int
7154 test_zuc_encryption_test_case_6_sgl(void)
7155 {
7156         return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b);
7157 }
7158
7159 static int
7160 test_zuc_hash_generate_test_case_1(void)
7161 {
7162         return test_zuc_authentication(&zuc_test_case_auth_1b);
7163 }
7164
7165 static int
7166 test_zuc_hash_generate_test_case_2(void)
7167 {
7168         return test_zuc_authentication(&zuc_test_case_auth_90b);
7169 }
7170
7171 static int
7172 test_zuc_hash_generate_test_case_3(void)
7173 {
7174         return test_zuc_authentication(&zuc_test_case_auth_577b);
7175 }
7176
7177 static int
7178 test_zuc_hash_generate_test_case_4(void)
7179 {
7180         return test_zuc_authentication(&zuc_test_case_auth_2079b);
7181 }
7182
7183 static int
7184 test_zuc_hash_generate_test_case_5(void)
7185 {
7186         return test_zuc_authentication(&zuc_test_auth_5670b);
7187 }
7188
7189 static int
7190 test_zuc_hash_generate_test_case_6(void)
7191 {
7192         return test_zuc_authentication(&zuc_test_case_auth_128b);
7193 }
7194
7195 static int
7196 test_zuc_hash_generate_test_case_7(void)
7197 {
7198         return test_zuc_authentication(&zuc_test_case_auth_2080b);
7199 }
7200
7201 static int
7202 test_zuc_hash_generate_test_case_8(void)
7203 {
7204         return test_zuc_authentication(&zuc_test_case_auth_584b);
7205 }
7206
7207 static int
7208 test_zuc_hash_generate_test_case_9(void)
7209 {
7210         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_32b);
7211 }
7212
7213 static int
7214 test_zuc_hash_generate_test_case_10(void)
7215 {
7216         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_64b);
7217 }
7218
7219 static int
7220 test_zuc_hash_generate_test_case_11(void)
7221 {
7222         return test_zuc_authentication(&zuc_test_case_auth_4000b_mac_128b);
7223 }
7224
7225 static int
7226 test_zuc_cipher_auth_test_case_1(void)
7227 {
7228         return test_zuc_cipher_auth(&zuc_test_case_cipher_200b_auth_200b);
7229 }
7230
7231 static int
7232 test_zuc_cipher_auth_test_case_2(void)
7233 {
7234         return test_zuc_cipher_auth(&zuc_test_case_cipher_800b_auth_120b);
7235 }
7236
7237 static int
7238 test_zuc_auth_cipher_test_case_1(void)
7239 {
7240         return test_zuc_auth_cipher(
7241                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7242 }
7243
7244 static int
7245 test_zuc_auth_cipher_test_case_1_oop(void)
7246 {
7247         return test_zuc_auth_cipher(
7248                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7249 }
7250
7251 static int
7252 test_zuc_auth_cipher_test_case_1_sgl(void)
7253 {
7254         return test_zuc_auth_cipher_sgl(
7255                 &zuc_auth_cipher_test_case_1, IN_PLACE, 0);
7256 }
7257
7258 static int
7259 test_zuc_auth_cipher_test_case_1_oop_sgl(void)
7260 {
7261         return test_zuc_auth_cipher_sgl(
7262                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 0);
7263 }
7264
7265 static int
7266 test_zuc_auth_cipher_verify_test_case_1(void)
7267 {
7268         return test_zuc_auth_cipher(
7269                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7270 }
7271
7272 static int
7273 test_zuc_auth_cipher_verify_test_case_1_oop(void)
7274 {
7275         return test_zuc_auth_cipher(
7276                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7277 }
7278
7279 static int
7280 test_zuc_auth_cipher_verify_test_case_1_sgl(void)
7281 {
7282         return test_zuc_auth_cipher_sgl(
7283                 &zuc_auth_cipher_test_case_1, IN_PLACE, 1);
7284 }
7285
7286 static int
7287 test_zuc_auth_cipher_verify_test_case_1_oop_sgl(void)
7288 {
7289         return test_zuc_auth_cipher_sgl(
7290                 &zuc_auth_cipher_test_case_1, OUT_OF_PLACE, 1);
7291 }
7292
7293 static int
7294 test_zuc256_encryption_test_case_1(void)
7295 {
7296         return test_zuc_encryption(&zuc256_test_case_cipher_1);
7297 }
7298
7299 static int
7300 test_zuc256_encryption_test_case_2(void)
7301 {
7302         return test_zuc_encryption(&zuc256_test_case_cipher_2);
7303 }
7304
7305 static int
7306 test_zuc256_authentication_test_case_1(void)
7307 {
7308         return test_zuc_authentication(&zuc256_test_case_auth_1);
7309 }
7310
7311 static int
7312 test_zuc256_authentication_test_case_2(void)
7313 {
7314         return test_zuc_authentication(&zuc256_test_case_auth_2);
7315 }
7316
7317 static int
7318 test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata)
7319 {
7320         uint8_t dev_id = testsuite_params.valid_devs[0];
7321
7322         struct rte_cryptodev_sym_capability_idx cap_idx;
7323
7324         /* Check if device supports particular cipher algorithm */
7325         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
7326         cap_idx.algo.cipher = tdata->cipher_algo;
7327         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7328                 return TEST_SKIPPED;
7329
7330         /* Check if device supports particular hash algorithm */
7331         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
7332         cap_idx.algo.auth = tdata->auth_algo;
7333         if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
7334                 return TEST_SKIPPED;
7335
7336         return 0;
7337 }
7338
7339 static int
7340 test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
7341         uint8_t op_mode, uint8_t verify)
7342 {
7343         struct crypto_testsuite_params *ts_params = &testsuite_params;
7344         struct crypto_unittest_params *ut_params = &unittest_params;
7345
7346         int retval;
7347
7348         uint8_t *plaintext = NULL, *ciphertext = NULL;
7349         unsigned int plaintext_pad_len;
7350         unsigned int plaintext_len;
7351         unsigned int ciphertext_pad_len;
7352         unsigned int ciphertext_len;
7353
7354         struct rte_cryptodev_info dev_info;
7355         struct rte_crypto_op *op;
7356
7357         /* Check if device supports particular algorithms separately */
7358         if (test_mixed_check_if_unsupported(tdata))
7359                 return TEST_SKIPPED;
7360         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7361                 return TEST_SKIPPED;
7362
7363         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7364
7365         uint64_t feat_flags = dev_info.feature_flags;
7366
7367         if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7368                 printf("Device doesn't support digest encrypted.\n");
7369                 return TEST_SKIPPED;
7370         }
7371
7372         /* Create the session */
7373         if (verify)
7374                 retval = create_wireless_algo_cipher_auth_session(
7375                                 ts_params->valid_devs[0],
7376                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7377                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7378                                 tdata->auth_algo,
7379                                 tdata->cipher_algo,
7380                                 tdata->auth_key.data, tdata->auth_key.len,
7381                                 tdata->auth_iv.len, tdata->digest_enc.len,
7382                                 tdata->cipher_iv.len);
7383         else
7384                 retval = create_wireless_algo_auth_cipher_session(
7385                                 ts_params->valid_devs[0],
7386                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7387                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7388                                 tdata->auth_algo,
7389                                 tdata->cipher_algo,
7390                                 tdata->auth_key.data, tdata->auth_key.len,
7391                                 tdata->auth_iv.len, tdata->digest_enc.len,
7392                                 tdata->cipher_iv.len);
7393         if (retval != 0)
7394                 return retval;
7395
7396         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7397         if (op_mode == OUT_OF_PLACE)
7398                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
7399
7400         /* clear mbuf payload */
7401         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
7402                 rte_pktmbuf_tailroom(ut_params->ibuf));
7403         if (op_mode == OUT_OF_PLACE) {
7404
7405                 memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
7406                                 rte_pktmbuf_tailroom(ut_params->obuf));
7407         }
7408
7409         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7410         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7411         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7412         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7413
7414         if (verify) {
7415                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7416                                 ciphertext_pad_len);
7417                 memcpy(ciphertext, tdata->ciphertext.data, ciphertext_len);
7418                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7419                                 ciphertext_len);
7420         } else {
7421                 /* make sure enough space to cover partial digest verify case */
7422                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
7423                                 ciphertext_pad_len);
7424                 memcpy(plaintext, tdata->plaintext.data, plaintext_len);
7425                 debug_hexdump(stdout, "plaintext:", plaintext, plaintext_len);
7426         }
7427
7428         if (op_mode == OUT_OF_PLACE)
7429                 rte_pktmbuf_append(ut_params->obuf, ciphertext_pad_len);
7430
7431         /* Create the operation */
7432         retval = create_wireless_algo_auth_cipher_operation(
7433                         tdata->digest_enc.data, tdata->digest_enc.len,
7434                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7435                         tdata->auth_iv.data, tdata->auth_iv.len,
7436                         (tdata->digest_enc.offset == 0 ?
7437                                 plaintext_pad_len
7438                                 : tdata->digest_enc.offset),
7439                         tdata->validCipherLen.len_bits,
7440                         tdata->cipher.offset_bits,
7441                         tdata->validAuthLen.len_bits,
7442                         tdata->auth.offset_bits,
7443                         op_mode, 0, verify);
7444
7445         if (retval < 0)
7446                 return retval;
7447
7448         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7449
7450         /* Check if the op failed because the device doesn't */
7451         /* support this particular combination of algorithms */
7452         if (op == NULL && ut_params->op->status ==
7453                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7454                 printf("Device doesn't support this mixed combination. "
7455                                 "Test Skipped.\n");
7456                 return TEST_SKIPPED;
7457         }
7458         ut_params->op = op;
7459
7460         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7461
7462         ut_params->obuf = (op_mode == IN_PLACE ?
7463                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7464
7465         if (verify) {
7466                 if (ut_params->obuf)
7467                         plaintext = rte_pktmbuf_mtod(ut_params->obuf,
7468                                                         uint8_t *);
7469                 else
7470                         plaintext = ciphertext +
7471                                         (tdata->cipher.offset_bits >> 3);
7472
7473                 debug_hexdump(stdout, "plaintext:", plaintext,
7474                                 tdata->plaintext.len_bits >> 3);
7475                 debug_hexdump(stdout, "plaintext expected:",
7476                                 tdata->plaintext.data,
7477                                 tdata->plaintext.len_bits >> 3);
7478         } else {
7479                 if (ut_params->obuf)
7480                         ciphertext = rte_pktmbuf_mtod(ut_params->obuf,
7481                                         uint8_t *);
7482                 else
7483                         ciphertext = plaintext;
7484
7485                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7486                                 ciphertext_len);
7487                 debug_hexdump(stdout, "ciphertext expected:",
7488                                 tdata->ciphertext.data,
7489                                 tdata->ciphertext.len_bits >> 3);
7490
7491                 ut_params->digest = rte_pktmbuf_mtod(ut_params->obuf, uint8_t *)
7492                                 + (tdata->digest_enc.offset == 0 ?
7493                 plaintext_pad_len : tdata->digest_enc.offset);
7494
7495                 debug_hexdump(stdout, "digest:", ut_params->digest,
7496                                 tdata->digest_enc.len);
7497                 debug_hexdump(stdout, "digest expected:",
7498                                 tdata->digest_enc.data,
7499                                 tdata->digest_enc.len);
7500         }
7501
7502         if (!verify) {
7503                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7504                                 ut_params->digest,
7505                                 tdata->digest_enc.data,
7506                                 tdata->digest_enc.len,
7507                                 "Generated auth tag not as expected");
7508         }
7509
7510         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7511                 if (verify) {
7512                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7513                                         plaintext,
7514                                         tdata->plaintext.data,
7515                                         tdata->plaintext.len_bits >> 3,
7516                                         "Plaintext data not as expected");
7517                 } else {
7518                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7519                                         ciphertext,
7520                                         tdata->ciphertext.data,
7521                                         tdata->validDataLen.len_bits,
7522                                         "Ciphertext data not as expected");
7523                 }
7524         }
7525
7526         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7527                         "crypto op processing failed");
7528
7529         return 0;
7530 }
7531
7532 static int
7533 test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
7534         uint8_t op_mode, uint8_t verify)
7535 {
7536         struct crypto_testsuite_params *ts_params = &testsuite_params;
7537         struct crypto_unittest_params *ut_params = &unittest_params;
7538
7539         int retval;
7540
7541         const uint8_t *plaintext = NULL;
7542         const uint8_t *ciphertext = NULL;
7543         const uint8_t *digest = NULL;
7544         unsigned int plaintext_pad_len;
7545         unsigned int plaintext_len;
7546         unsigned int ciphertext_pad_len;
7547         unsigned int ciphertext_len;
7548         uint8_t buffer[10000];
7549         uint8_t digest_buffer[10000];
7550
7551         struct rte_cryptodev_info dev_info;
7552         struct rte_crypto_op *op;
7553
7554         /* Check if device supports particular algorithms */
7555         if (test_mixed_check_if_unsupported(tdata))
7556                 return TEST_SKIPPED;
7557         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
7558                 return TEST_SKIPPED;
7559
7560         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
7561
7562         uint64_t feat_flags = dev_info.feature_flags;
7563
7564         if (op_mode == IN_PLACE) {
7565                 if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
7566                         printf("Device doesn't support in-place scatter-gather "
7567                                         "in both input and output mbufs.\n");
7568                         return TEST_SKIPPED;
7569                 }
7570         } else {
7571                 if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
7572                         printf("Device doesn't support out-of-place scatter-gather "
7573                                         "in both input and output mbufs.\n");
7574                         return TEST_SKIPPED;
7575                 }
7576                 if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
7577                         printf("Device doesn't support digest encrypted.\n");
7578                         return TEST_SKIPPED;
7579                 }
7580         }
7581
7582         /* Create the session */
7583         if (verify)
7584                 retval = create_wireless_algo_cipher_auth_session(
7585                                 ts_params->valid_devs[0],
7586                                 RTE_CRYPTO_CIPHER_OP_DECRYPT,
7587                                 RTE_CRYPTO_AUTH_OP_VERIFY,
7588                                 tdata->auth_algo,
7589                                 tdata->cipher_algo,
7590                                 tdata->auth_key.data, tdata->auth_key.len,
7591                                 tdata->auth_iv.len, tdata->digest_enc.len,
7592                                 tdata->cipher_iv.len);
7593         else
7594                 retval = create_wireless_algo_auth_cipher_session(
7595                                 ts_params->valid_devs[0],
7596                                 RTE_CRYPTO_CIPHER_OP_ENCRYPT,
7597                                 RTE_CRYPTO_AUTH_OP_GENERATE,
7598                                 tdata->auth_algo,
7599                                 tdata->cipher_algo,
7600                                 tdata->auth_key.data, tdata->auth_key.len,
7601                                 tdata->auth_iv.len, tdata->digest_enc.len,
7602                                 tdata->cipher_iv.len);
7603         if (retval != 0)
7604                 return retval;
7605
7606         ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
7607         plaintext_len = ceil_byte_length(tdata->plaintext.len_bits);
7608         ciphertext_pad_len = RTE_ALIGN_CEIL(ciphertext_len, 16);
7609         plaintext_pad_len = RTE_ALIGN_CEIL(plaintext_len, 16);
7610
7611         ut_params->ibuf = create_segmented_mbuf(ts_params->mbuf_pool,
7612                         ciphertext_pad_len, 15, 0);
7613         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
7614                         "Failed to allocate input buffer in mempool");
7615
7616         if (op_mode == OUT_OF_PLACE) {
7617                 ut_params->obuf = create_segmented_mbuf(ts_params->mbuf_pool,
7618                                 plaintext_pad_len, 15, 0);
7619                 TEST_ASSERT_NOT_NULL(ut_params->obuf,
7620                                 "Failed to allocate output buffer in mempool");
7621         }
7622
7623         if (verify) {
7624                 pktmbuf_write(ut_params->ibuf, 0, ciphertext_len,
7625                         tdata->ciphertext.data);
7626                 ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7627                                         ciphertext_len, buffer);
7628                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7629                         ciphertext_len);
7630         } else {
7631                 pktmbuf_write(ut_params->ibuf, 0, plaintext_len,
7632                         tdata->plaintext.data);
7633                 plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7634                                         plaintext_len, buffer);
7635                 debug_hexdump(stdout, "plaintext:", plaintext,
7636                         plaintext_len);
7637         }
7638         memset(buffer, 0, sizeof(buffer));
7639
7640         /* Create the operation */
7641         retval = create_wireless_algo_auth_cipher_operation(
7642                         tdata->digest_enc.data, tdata->digest_enc.len,
7643                         tdata->cipher_iv.data, tdata->cipher_iv.len,
7644                         tdata->auth_iv.data, tdata->auth_iv.len,
7645                         (tdata->digest_enc.offset == 0 ?
7646                                 plaintext_pad_len
7647                                 : tdata->digest_enc.offset),
7648                         tdata->validCipherLen.len_bits,
7649                         tdata->cipher.offset_bits,
7650                         tdata->validAuthLen.len_bits,
7651                         tdata->auth.offset_bits,
7652                         op_mode, 1, verify);
7653
7654         if (retval < 0)
7655                 return retval;
7656
7657         op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
7658
7659         /* Check if the op failed because the device doesn't */
7660         /* support this particular combination of algorithms */
7661         if (op == NULL && ut_params->op->status ==
7662                         RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
7663                 printf("Device doesn't support this mixed combination. "
7664                                 "Test Skipped.\n");
7665                 return TEST_SKIPPED;
7666         }
7667         ut_params->op = op;
7668
7669         TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
7670
7671         ut_params->obuf = (op_mode == IN_PLACE ?
7672                         ut_params->op->sym->m_src : ut_params->op->sym->m_dst);
7673
7674         if (verify) {
7675                 if (ut_params->obuf)
7676                         plaintext = rte_pktmbuf_read(ut_params->obuf, 0,
7677                                         plaintext_len, buffer);
7678                 else
7679                         plaintext = rte_pktmbuf_read(ut_params->ibuf, 0,
7680                                         plaintext_len, buffer);
7681
7682                 debug_hexdump(stdout, "plaintext:", plaintext,
7683                                 (tdata->plaintext.len_bits >> 3) -
7684                                 tdata->digest_enc.len);
7685                 debug_hexdump(stdout, "plaintext expected:",
7686                                 tdata->plaintext.data,
7687                                 (tdata->plaintext.len_bits >> 3) -
7688                                 tdata->digest_enc.len);
7689         } else {
7690                 if (ut_params->obuf)
7691                         ciphertext = rte_pktmbuf_read(ut_params->obuf, 0,
7692                                         ciphertext_len, buffer);
7693                 else
7694                         ciphertext = rte_pktmbuf_read(ut_params->ibuf, 0,
7695                                         ciphertext_len, buffer);
7696
7697                 debug_hexdump(stdout, "ciphertext:", ciphertext,
7698                         ciphertext_len);
7699                 debug_hexdump(stdout, "ciphertext expected:",
7700                         tdata->ciphertext.data,
7701                         tdata->ciphertext.len_bits >> 3);
7702
7703                 if (ut_params->obuf)
7704                         digest = rte_pktmbuf_read(ut_params->obuf,
7705                                         (tdata->digest_enc.offset == 0 ?
7706                                                 plaintext_pad_len :
7707                                                 tdata->digest_enc.offset),
7708                                         tdata->digest_enc.len, digest_buffer);
7709                 else
7710                         digest = rte_pktmbuf_read(ut_params->ibuf,
7711                                         (tdata->digest_enc.offset == 0 ?
7712                                                 plaintext_pad_len :
7713                                                 tdata->digest_enc.offset),
7714                                         tdata->digest_enc.len, digest_buffer);
7715
7716                 debug_hexdump(stdout, "digest:", digest,
7717                                 tdata->digest_enc.len);
7718                 debug_hexdump(stdout, "digest expected:",
7719                                 tdata->digest_enc.data, tdata->digest_enc.len);
7720         }
7721
7722         if (!verify) {
7723                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
7724                                 digest,
7725                                 tdata->digest_enc.data,
7726                                 tdata->digest_enc.len,
7727                                 "Generated auth tag not as expected");
7728         }
7729
7730         if (tdata->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
7731                 if (verify) {
7732                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7733                                         plaintext,
7734                                         tdata->plaintext.data,
7735                                         tdata->plaintext.len_bits >> 3,
7736                                         "Plaintext data not as expected");
7737                 } else {
7738                         TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
7739                                         ciphertext,
7740                                         tdata->ciphertext.data,
7741                                         tdata->validDataLen.len_bits,
7742                                         "Ciphertext data not as expected");
7743                 }
7744         }
7745
7746         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
7747                         "crypto op processing failed");
7748
7749         return 0;
7750 }
7751
7752 /** AUTH AES CMAC + CIPHER AES CTR */
7753
7754 static int
7755 test_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7756 {
7757         return test_mixed_auth_cipher(
7758                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7759 }
7760
7761 static int
7762 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7763 {
7764         return test_mixed_auth_cipher(
7765                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7766 }
7767
7768 static int
7769 test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7770 {
7771         return test_mixed_auth_cipher_sgl(
7772                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 0);
7773 }
7774
7775 static int
7776 test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7777 {
7778         return test_mixed_auth_cipher_sgl(
7779                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7780 }
7781
7782 static int
7783 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1(void)
7784 {
7785         return test_mixed_auth_cipher(
7786                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7787 }
7788
7789 static int
7790 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop(void)
7791 {
7792         return test_mixed_auth_cipher(
7793                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7794 }
7795
7796 static int
7797 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl(void)
7798 {
7799         return test_mixed_auth_cipher_sgl(
7800                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, IN_PLACE, 1);
7801 }
7802
7803 static int
7804 test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl(void)
7805 {
7806         return test_mixed_auth_cipher_sgl(
7807                 &auth_aes_cmac_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7808 }
7809
7810 /** MIXED AUTH + CIPHER */
7811
7812 static int
7813 test_auth_zuc_cipher_snow_test_case_1(void)
7814 {
7815         return test_mixed_auth_cipher(
7816                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7817 }
7818
7819 static int
7820 test_verify_auth_zuc_cipher_snow_test_case_1(void)
7821 {
7822         return test_mixed_auth_cipher(
7823                 &auth_zuc_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7824 }
7825
7826 static int
7827 test_auth_aes_cmac_cipher_snow_test_case_1(void)
7828 {
7829         return test_mixed_auth_cipher(
7830                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7831 }
7832
7833 static int
7834 test_verify_auth_aes_cmac_cipher_snow_test_case_1(void)
7835 {
7836         return test_mixed_auth_cipher(
7837                 &auth_aes_cmac_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7838 }
7839
7840 static int
7841 test_auth_zuc_cipher_aes_ctr_test_case_1(void)
7842 {
7843         return test_mixed_auth_cipher(
7844                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7845 }
7846
7847 static int
7848 test_verify_auth_zuc_cipher_aes_ctr_test_case_1(void)
7849 {
7850         return test_mixed_auth_cipher(
7851                 &auth_zuc_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7852 }
7853
7854 static int
7855 test_auth_snow_cipher_aes_ctr_test_case_1(void)
7856 {
7857         return test_mixed_auth_cipher(
7858                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7859 }
7860
7861 static int
7862 test_verify_auth_snow_cipher_aes_ctr_test_case_1(void)
7863 {
7864         return test_mixed_auth_cipher(
7865                 &auth_snow_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7866 }
7867
7868 static int
7869 test_auth_snow_cipher_zuc_test_case_1(void)
7870 {
7871         return test_mixed_auth_cipher(
7872                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7873 }
7874
7875 static int
7876 test_verify_auth_snow_cipher_zuc_test_case_1(void)
7877 {
7878         return test_mixed_auth_cipher(
7879                 &auth_snow_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7880 }
7881
7882 static int
7883 test_auth_aes_cmac_cipher_zuc_test_case_1(void)
7884 {
7885         return test_mixed_auth_cipher(
7886                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7887 }
7888
7889 static int
7890 test_verify_auth_aes_cmac_cipher_zuc_test_case_1(void)
7891 {
7892         return test_mixed_auth_cipher(
7893                 &auth_aes_cmac_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7894 }
7895
7896 static int
7897 test_auth_null_cipher_snow_test_case_1(void)
7898 {
7899         return test_mixed_auth_cipher(
7900                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 0);
7901 }
7902
7903 static int
7904 test_verify_auth_null_cipher_snow_test_case_1(void)
7905 {
7906         return test_mixed_auth_cipher(
7907                 &auth_null_cipher_snow_test_case_1, OUT_OF_PLACE, 1);
7908 }
7909
7910 static int
7911 test_auth_null_cipher_zuc_test_case_1(void)
7912 {
7913         return test_mixed_auth_cipher(
7914                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 0);
7915 }
7916
7917 static int
7918 test_verify_auth_null_cipher_zuc_test_case_1(void)
7919 {
7920         return test_mixed_auth_cipher(
7921                 &auth_null_cipher_zuc_test_case_1, OUT_OF_PLACE, 1);
7922 }
7923
7924 static int
7925 test_auth_snow_cipher_null_test_case_1(void)
7926 {
7927         return test_mixed_auth_cipher(
7928                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7929 }
7930
7931 static int
7932 test_verify_auth_snow_cipher_null_test_case_1(void)
7933 {
7934         return test_mixed_auth_cipher(
7935                 &auth_snow_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7936 }
7937
7938 static int
7939 test_auth_zuc_cipher_null_test_case_1(void)
7940 {
7941         return test_mixed_auth_cipher(
7942                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7943 }
7944
7945 static int
7946 test_verify_auth_zuc_cipher_null_test_case_1(void)
7947 {
7948         return test_mixed_auth_cipher(
7949                 &auth_zuc_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7950 }
7951
7952 static int
7953 test_auth_null_cipher_aes_ctr_test_case_1(void)
7954 {
7955         return test_mixed_auth_cipher(
7956                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 0);
7957 }
7958
7959 static int
7960 test_verify_auth_null_cipher_aes_ctr_test_case_1(void)
7961 {
7962         return test_mixed_auth_cipher(
7963                 &auth_null_cipher_aes_ctr_test_case_1, OUT_OF_PLACE, 1);
7964 }
7965
7966 static int
7967 test_auth_aes_cmac_cipher_null_test_case_1(void)
7968 {
7969         return test_mixed_auth_cipher(
7970                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 0);
7971 }
7972
7973 static int
7974 test_verify_auth_aes_cmac_cipher_null_test_case_1(void)
7975 {
7976         return test_mixed_auth_cipher(
7977                 &auth_aes_cmac_cipher_null_test_case_1, OUT_OF_PLACE, 1);
7978 }
7979
7980 /* ***** AEAD algorithm Tests ***** */
7981
7982 static int
7983 create_aead_session(uint8_t dev_id, enum rte_crypto_aead_algorithm algo,
7984                 enum rte_crypto_aead_operation op,
7985                 const uint8_t *key, const uint8_t key_len,
7986                 const uint16_t aad_len, const uint8_t auth_len,
7987                 uint8_t iv_len)
7988 {
7989         uint8_t aead_key[key_len];
7990         int status;
7991
7992         struct crypto_testsuite_params *ts_params = &testsuite_params;
7993         struct crypto_unittest_params *ut_params = &unittest_params;
7994
7995         memcpy(aead_key, key, key_len);
7996
7997         /* Setup AEAD Parameters */
7998         ut_params->aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
7999         ut_params->aead_xform.next = NULL;
8000         ut_params->aead_xform.aead.algo = algo;
8001         ut_params->aead_xform.aead.op = op;
8002         ut_params->aead_xform.aead.key.data = aead_key;
8003         ut_params->aead_xform.aead.key.length = key_len;
8004         ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
8005         ut_params->aead_xform.aead.iv.length = iv_len;
8006         ut_params->aead_xform.aead.digest_length = auth_len;
8007         ut_params->aead_xform.aead.aad_length = aad_len;
8008
8009         debug_hexdump(stdout, "key:", key, key_len);
8010
8011         /* Create Crypto session*/
8012         ut_params->sess = rte_cryptodev_sym_session_create(
8013                         ts_params->session_mpool);
8014         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
8015
8016         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
8017                         &ut_params->aead_xform,
8018                         ts_params->session_priv_mpool);
8019
8020         return status;
8021 }
8022
8023 static int
8024 create_aead_xform(struct rte_crypto_op *op,
8025                 enum rte_crypto_aead_algorithm algo,
8026                 enum rte_crypto_aead_operation aead_op,
8027                 uint8_t *key, const uint8_t key_len,
8028                 const uint8_t aad_len, const uint8_t auth_len,
8029                 uint8_t iv_len)
8030 {
8031         TEST_ASSERT_NOT_NULL(rte_crypto_op_sym_xforms_alloc(op, 1),
8032                         "failed to allocate space for crypto transform");
8033
8034         struct rte_crypto_sym_op *sym_op = op->sym;
8035
8036         /* Setup AEAD Parameters */
8037         sym_op->xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
8038         sym_op->xform->next = NULL;
8039         sym_op->xform->aead.algo = algo;
8040         sym_op->xform->aead.op = aead_op;
8041         sym_op->xform->aead.key.data = key;
8042         sym_op->xform->aead.key.length = key_len;
8043         sym_op->xform->aead.iv.offset = IV_OFFSET;
8044         sym_op->xform->aead.iv.length = iv_len;
8045         sym_op->xform->aead.digest_length = auth_len;
8046         sym_op->xform->aead.aad_length = aad_len;
8047
8048         debug_hexdump(stdout, "key:", key, key_len);
8049
8050         return 0;
8051 }
8052
8053 static int
8054 create_aead_operation(enum rte_crypto_aead_operation op,
8055                 const struct aead_test_data *tdata)
8056 {
8057         struct crypto_testsuite_params *ts_params = &testsuite_params;
8058         struct crypto_unittest_params *ut_params = &unittest_params;
8059
8060         uint8_t *plaintext, *ciphertext;
8061         unsigned int aad_pad_len, plaintext_pad_len;
8062
8063         /* Generate Crypto op data structure */
8064         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8065                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8066         TEST_ASSERT_NOT_NULL(ut_params->op,
8067                         "Failed to allocate symmetric crypto operation struct");
8068
8069         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
8070
8071         /* Append aad data */
8072         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
8073                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len + 18, 16);
8074                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8075                                 aad_pad_len);
8076                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8077                                 "no room to append aad");
8078
8079                 sym_op->aead.aad.phys_addr =
8080                                 rte_pktmbuf_iova(ut_params->ibuf);
8081                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
8082                 memcpy(sym_op->aead.aad.data + 18, tdata->aad.data, tdata->aad.len);
8083                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8084                         tdata->aad.len);
8085
8086                 /* Append IV at the end of the crypto operation*/
8087                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8088                                 uint8_t *, IV_OFFSET);
8089
8090                 /* Copy IV 1 byte after the IV pointer, according to the API */
8091                 rte_memcpy(iv_ptr + 1, tdata->iv.data, tdata->iv.len);
8092                 debug_hexdump(stdout, "iv:", iv_ptr,
8093                         tdata->iv.len);
8094         } else {
8095                 aad_pad_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
8096                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8097                                 aad_pad_len);
8098                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
8099                                 "no room to append aad");
8100
8101                 sym_op->aead.aad.phys_addr =
8102                                 rte_pktmbuf_iova(ut_params->ibuf);
8103                 memcpy(sym_op->aead.aad.data, tdata->aad.data, tdata->aad.len);
8104                 debug_hexdump(stdout, "aad:", sym_op->aead.aad.data,
8105                         tdata->aad.len);
8106
8107                 /* Append IV at the end of the crypto operation*/
8108                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
8109                                 uint8_t *, IV_OFFSET);
8110
8111                 if (tdata->iv.len == 0) {
8112                         rte_memcpy(iv_ptr, tdata->iv.data, AES_GCM_J0_LENGTH);
8113                         debug_hexdump(stdout, "iv:", iv_ptr,
8114                                 AES_GCM_J0_LENGTH);
8115                 } else {
8116                         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
8117                         debug_hexdump(stdout, "iv:", iv_ptr,
8118                                 tdata->iv.len);
8119                 }
8120         }
8121
8122         /* Append plaintext/ciphertext */
8123         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8124                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8125                 plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8126                                 plaintext_pad_len);
8127                 TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
8128
8129                 memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
8130                 debug_hexdump(stdout, "plaintext:", plaintext,
8131                                 tdata->plaintext.len);
8132
8133                 if (ut_params->obuf) {
8134                         ciphertext = (uint8_t *)rte_pktmbuf_append(
8135                                         ut_params->obuf,
8136                                         plaintext_pad_len + aad_pad_len);
8137                         TEST_ASSERT_NOT_NULL(ciphertext,
8138                                         "no room to append ciphertext");
8139
8140                         memset(ciphertext + aad_pad_len, 0,
8141                                         tdata->ciphertext.len);
8142                 }
8143         } else {
8144                 plaintext_pad_len = RTE_ALIGN_CEIL(tdata->ciphertext.len, 16);
8145                 ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8146                                 plaintext_pad_len);
8147                 TEST_ASSERT_NOT_NULL(ciphertext,
8148                                 "no room to append ciphertext");
8149
8150                 memcpy(ciphertext, tdata->ciphertext.data,
8151                                 tdata->ciphertext.len);
8152                 debug_hexdump(stdout, "ciphertext:", ciphertext,
8153                                 tdata->ciphertext.len);
8154
8155                 if (ut_params->obuf) {
8156                         plaintext = (uint8_t *)rte_pktmbuf_append(
8157                                         ut_params->obuf,
8158                                         plaintext_pad_len + aad_pad_len);
8159                         TEST_ASSERT_NOT_NULL(plaintext,
8160                                         "no room to append plaintext");
8161
8162                         memset(plaintext + aad_pad_len, 0,
8163                                         tdata->plaintext.len);
8164                 }
8165         }
8166
8167         /* Append digest data */
8168         if (op == RTE_CRYPTO_AEAD_OP_ENCRYPT) {
8169                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8170                                 ut_params->obuf ? ut_params->obuf :
8171                                                 ut_params->ibuf,
8172                                                 tdata->auth_tag.len);
8173                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8174                                 "no room to append digest");
8175                 memset(sym_op->aead.digest.data, 0, tdata->auth_tag.len);
8176                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8177                                 ut_params->obuf ? ut_params->obuf :
8178                                                 ut_params->ibuf,
8179                                                 plaintext_pad_len +
8180                                                 aad_pad_len);
8181         } else {
8182                 sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
8183                                 ut_params->ibuf, tdata->auth_tag.len);
8184                 TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
8185                                 "no room to append digest");
8186                 sym_op->aead.digest.phys_addr = rte_pktmbuf_iova_offset(
8187                                 ut_params->ibuf,
8188                                 plaintext_pad_len + aad_pad_len);
8189
8190                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
8191                         tdata->auth_tag.len);
8192                 debug_hexdump(stdout, "digest:",
8193                         sym_op->aead.digest.data,
8194                         tdata->auth_tag.len);
8195         }
8196
8197         sym_op->aead.data.length = tdata->plaintext.len;
8198         sym_op->aead.data.offset = aad_pad_len;
8199
8200         return 0;
8201 }
8202
8203 static int
8204 test_authenticated_encryption(const struct aead_test_data *tdata)
8205 {
8206         struct crypto_testsuite_params *ts_params = &testsuite_params;
8207         struct crypto_unittest_params *ut_params = &unittest_params;
8208
8209         int retval;
8210         uint8_t *ciphertext, *auth_tag;
8211         uint16_t plaintext_pad_len;
8212         uint32_t i;
8213         struct rte_cryptodev_info dev_info;
8214
8215         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8216         uint64_t feat_flags = dev_info.feature_flags;
8217
8218         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8219                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8220                 printf("Device doesn't support RAW data-path APIs.\n");
8221                 return TEST_SKIPPED;
8222         }
8223
8224         /* Verify the capabilities */
8225         struct rte_cryptodev_sym_capability_idx cap_idx;
8226         const struct rte_cryptodev_symmetric_capability *capability;
8227         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
8228         cap_idx.algo.aead = tdata->algo;
8229         capability = rte_cryptodev_sym_capability_get(
8230                         ts_params->valid_devs[0], &cap_idx);
8231         if (capability == NULL)
8232                 return TEST_SKIPPED;
8233         if (rte_cryptodev_sym_capability_check_aead(
8234                         capability, tdata->key.len, tdata->auth_tag.len,
8235                         tdata->aad.len, tdata->iv.len))
8236                 return TEST_SKIPPED;
8237
8238         /* Create AEAD session */
8239         retval = create_aead_session(ts_params->valid_devs[0],
8240                         tdata->algo,
8241                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
8242                         tdata->key.data, tdata->key.len,
8243                         tdata->aad.len, tdata->auth_tag.len,
8244                         tdata->iv.len);
8245         if (retval < 0)
8246                 return retval;
8247
8248         if (tdata->aad.len > MBUF_SIZE) {
8249                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
8250                 /* Populate full size of add data */
8251                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
8252                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
8253         } else
8254                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8255
8256         /* clear mbuf payload */
8257         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8258                         rte_pktmbuf_tailroom(ut_params->ibuf));
8259
8260         /* Create AEAD operation */
8261         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
8262         if (retval < 0)
8263                 return retval;
8264
8265         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
8266
8267         ut_params->op->sym->m_src = ut_params->ibuf;
8268
8269         /* Process crypto operation */
8270         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
8271                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
8272         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
8273                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8274                                 ut_params->op, 0, 0, 0, 0);
8275         else
8276                 TEST_ASSERT_NOT_NULL(
8277                         process_crypto_request(ts_params->valid_devs[0],
8278                         ut_params->op), "failed to process sym crypto op");
8279
8280         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
8281                         "crypto op processing failed");
8282
8283         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
8284
8285         if (ut_params->op->sym->m_dst) {
8286                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8287                                 uint8_t *);
8288                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
8289                                 uint8_t *, plaintext_pad_len);
8290         } else {
8291                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
8292                                 uint8_t *,
8293                                 ut_params->op->sym->cipher.data.offset);
8294                 auth_tag = ciphertext + plaintext_pad_len;
8295         }
8296
8297         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
8298         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
8299
8300         /* Validate obuf */
8301         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8302                         ciphertext,
8303                         tdata->ciphertext.data,
8304                         tdata->ciphertext.len,
8305                         "Ciphertext data not as expected");
8306
8307         TEST_ASSERT_BUFFERS_ARE_EQUAL(
8308                         auth_tag,
8309                         tdata->auth_tag.data,
8310                         tdata->auth_tag.len,
8311                         "Generated auth tag not as expected");
8312
8313         return 0;
8314
8315 }
8316
8317 #ifdef RTE_LIB_SECURITY
8318 static int
8319 security_proto_supported(enum rte_security_session_action_type action,
8320         enum rte_security_session_protocol proto)
8321 {
8322         struct crypto_testsuite_params *ts_params = &testsuite_params;
8323
8324         const struct rte_security_capability *capabilities;
8325         const struct rte_security_capability *capability;
8326         uint16_t i = 0;
8327
8328         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8329                                 rte_cryptodev_get_sec_ctx(
8330                                 ts_params->valid_devs[0]);
8331
8332
8333         capabilities = rte_security_capabilities_get(ctx);
8334
8335         if (capabilities == NULL)
8336                 return -ENOTSUP;
8337
8338         while ((capability = &capabilities[i++])->action !=
8339                         RTE_SECURITY_ACTION_TYPE_NONE) {
8340                 if (capability->action == action &&
8341                                 capability->protocol == proto)
8342                         return 0;
8343         }
8344
8345         return -ENOTSUP;
8346 }
8347
8348 /* Basic algorithm run function for async inplace mode.
8349  * Creates a session from input parameters and runs one operation
8350  * on input_vec. Checks the output of the crypto operation against
8351  * output_vec.
8352  */
8353 static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
8354                            enum rte_crypto_auth_operation opa,
8355                            const uint8_t *input_vec, unsigned int input_vec_len,
8356                            const uint8_t *output_vec,
8357                            unsigned int output_vec_len,
8358                            enum rte_crypto_cipher_algorithm cipher_alg,
8359                            const uint8_t *cipher_key, uint32_t cipher_key_len,
8360                            enum rte_crypto_auth_algorithm auth_alg,
8361                            const uint8_t *auth_key, uint32_t auth_key_len,
8362                            uint8_t bearer, enum rte_security_pdcp_domain domain,
8363                            uint8_t packet_direction, uint8_t sn_size,
8364                            uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
8365 {
8366         struct crypto_testsuite_params *ts_params = &testsuite_params;
8367         struct crypto_unittest_params *ut_params = &unittest_params;
8368         uint8_t *plaintext;
8369         int ret = TEST_SUCCESS;
8370         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8371                                 rte_cryptodev_get_sec_ctx(
8372                                 ts_params->valid_devs[0]);
8373
8374         /* Verify the capabilities */
8375         struct rte_security_capability_idx sec_cap_idx;
8376
8377         sec_cap_idx.action = ut_params->type;
8378         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8379         sec_cap_idx.pdcp.domain = domain;
8380         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8381                 return TEST_SKIPPED;
8382
8383         /* Generate test mbuf data */
8384         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8385
8386         /* clear mbuf payload */
8387         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8388                         rte_pktmbuf_tailroom(ut_params->ibuf));
8389
8390         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8391                                                   input_vec_len);
8392         memcpy(plaintext, input_vec, input_vec_len);
8393
8394         /* Out of place support */
8395         if (oop) {
8396                 /*
8397                  * For out-op-place we need to alloc another mbuf
8398                  */
8399                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8400                 rte_pktmbuf_append(ut_params->obuf, output_vec_len);
8401         }
8402
8403         /* Setup Cipher Parameters */
8404         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8405         ut_params->cipher_xform.cipher.algo = cipher_alg;
8406         ut_params->cipher_xform.cipher.op = opc;
8407         ut_params->cipher_xform.cipher.key.data = cipher_key;
8408         ut_params->cipher_xform.cipher.key.length = cipher_key_len;
8409         ut_params->cipher_xform.cipher.iv.length =
8410                                 packet_direction ? 4 : 0;
8411         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
8412
8413         /* Setup HMAC Parameters if ICV header is required */
8414         if (auth_alg != 0) {
8415                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8416                 ut_params->auth_xform.next = NULL;
8417                 ut_params->auth_xform.auth.algo = auth_alg;
8418                 ut_params->auth_xform.auth.op = opa;
8419                 ut_params->auth_xform.auth.key.data = auth_key;
8420                 ut_params->auth_xform.auth.key.length = auth_key_len;
8421
8422                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8423         } else {
8424                 ut_params->cipher_xform.next = NULL;
8425         }
8426
8427         struct rte_security_session_conf sess_conf = {
8428                 .action_type = ut_params->type,
8429                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8430                 {.pdcp = {
8431                         .bearer = bearer,
8432                         .domain = domain,
8433                         .pkt_dir = packet_direction,
8434                         .sn_size = sn_size,
8435                         .hfn = packet_direction ? 0 : hfn,
8436                         /**
8437                          * hfn can be set as pdcp_test_hfn[i]
8438                          * if hfn_ovrd is not set. Here, PDCP
8439                          * packet direction is just used to
8440                          * run half of the cases with session
8441                          * HFN and other half with per packet
8442                          * HFN.
8443                          */
8444                         .hfn_threshold = hfn_threshold,
8445                         .hfn_ovrd = packet_direction ? 1 : 0,
8446                         .sdap_enabled = sdap,
8447                 } },
8448                 .crypto_xform = &ut_params->cipher_xform
8449         };
8450
8451         /* Create security session */
8452         ut_params->sec_session = rte_security_session_create(ctx,
8453                                 &sess_conf, ts_params->session_mpool,
8454                                 ts_params->session_priv_mpool);
8455
8456         if (!ut_params->sec_session) {
8457                 printf("TestCase %s()-%d line %d failed %s: ",
8458                         __func__, i, __LINE__, "Failed to allocate session");
8459                 ret = TEST_FAILED;
8460                 goto on_err;
8461         }
8462
8463         /* Generate crypto op data structure */
8464         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8465                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8466         if (!ut_params->op) {
8467                 printf("TestCase %s()-%d line %d failed %s: ",
8468                         __func__, i, __LINE__,
8469                         "Failed to allocate symmetric crypto operation struct");
8470                 ret = TEST_FAILED;
8471                 goto on_err;
8472         }
8473
8474         uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
8475                                         uint32_t *, IV_OFFSET);
8476         *per_pkt_hfn = packet_direction ? hfn : 0;
8477
8478         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8479
8480         /* set crypto operation source mbuf */
8481         ut_params->op->sym->m_src = ut_params->ibuf;
8482         if (oop)
8483                 ut_params->op->sym->m_dst = ut_params->obuf;
8484
8485         /* Process crypto operation */
8486         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op)
8487                 == NULL) {
8488                 printf("TestCase %s()-%d line %d failed %s: ",
8489                         __func__, i, __LINE__,
8490                         "failed to process sym crypto op");
8491                 ret = TEST_FAILED;
8492                 goto on_err;
8493         }
8494
8495         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8496                 printf("TestCase %s()-%d line %d failed %s: ",
8497                         __func__, i, __LINE__, "crypto op processing failed");
8498                 ret = TEST_FAILED;
8499                 goto on_err;
8500         }
8501
8502         /* Validate obuf */
8503         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8504                         uint8_t *);
8505         if (oop) {
8506                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8507                                 uint8_t *);
8508         }
8509
8510         if (memcmp(ciphertext, output_vec, output_vec_len)) {
8511                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8512                 rte_hexdump(stdout, "encrypted", ciphertext, output_vec_len);
8513                 rte_hexdump(stdout, "reference", output_vec, output_vec_len);
8514                 ret = TEST_FAILED;
8515                 goto on_err;
8516         }
8517
8518 on_err:
8519         rte_crypto_op_free(ut_params->op);
8520         ut_params->op = NULL;
8521
8522         if (ut_params->sec_session)
8523                 rte_security_session_destroy(ctx, ut_params->sec_session);
8524         ut_params->sec_session = NULL;
8525
8526         rte_pktmbuf_free(ut_params->ibuf);
8527         ut_params->ibuf = NULL;
8528         if (oop) {
8529                 rte_pktmbuf_free(ut_params->obuf);
8530                 ut_params->obuf = NULL;
8531         }
8532
8533         return ret;
8534 }
8535
8536 static int
8537 test_pdcp_proto_SGL(int i, int oop,
8538         enum rte_crypto_cipher_operation opc,
8539         enum rte_crypto_auth_operation opa,
8540         uint8_t *input_vec,
8541         unsigned int input_vec_len,
8542         uint8_t *output_vec,
8543         unsigned int output_vec_len,
8544         uint32_t fragsz,
8545         uint32_t fragsz_oop)
8546 {
8547         struct crypto_testsuite_params *ts_params = &testsuite_params;
8548         struct crypto_unittest_params *ut_params = &unittest_params;
8549         uint8_t *plaintext;
8550         struct rte_mbuf *buf, *buf_oop = NULL;
8551         int ret = TEST_SUCCESS;
8552         int to_trn = 0;
8553         int to_trn_tbl[16];
8554         int segs = 1;
8555         unsigned int trn_data = 0;
8556         struct rte_cryptodev_info dev_info;
8557         uint64_t feat_flags;
8558         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
8559                                 rte_cryptodev_get_sec_ctx(
8560                                 ts_params->valid_devs[0]);
8561         struct rte_mbuf *temp_mbuf;
8562
8563         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
8564         feat_flags = dev_info.feature_flags;
8565
8566         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
8567                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
8568                 printf("Device does not support RAW data-path APIs.\n");
8569                 return -ENOTSUP;
8570         }
8571         /* Verify the capabilities */
8572         struct rte_security_capability_idx sec_cap_idx;
8573
8574         sec_cap_idx.action = ut_params->type;
8575         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
8576         sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
8577         if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
8578                 return TEST_SKIPPED;
8579
8580         if (fragsz > input_vec_len)
8581                 fragsz = input_vec_len;
8582
8583         uint16_t plaintext_len = fragsz;
8584         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
8585
8586         if (fragsz_oop > output_vec_len)
8587                 frag_size_oop = output_vec_len;
8588
8589         int ecx = 0;
8590         if (input_vec_len % fragsz != 0) {
8591                 if (input_vec_len / fragsz + 1 > 16)
8592                         return 1;
8593         } else if (input_vec_len / fragsz > 16)
8594                 return 1;
8595
8596         /* Out of place support */
8597         if (oop) {
8598                 /*
8599                  * For out-op-place we need to alloc another mbuf
8600                  */
8601                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8602                 rte_pktmbuf_append(ut_params->obuf, frag_size_oop);
8603                 buf_oop = ut_params->obuf;
8604         }
8605
8606         /* Generate test mbuf data */
8607         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8608
8609         /* clear mbuf payload */
8610         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
8611                         rte_pktmbuf_tailroom(ut_params->ibuf));
8612
8613         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
8614                                                   plaintext_len);
8615         memcpy(plaintext, input_vec, plaintext_len);
8616         trn_data += plaintext_len;
8617
8618         buf = ut_params->ibuf;
8619
8620         /*
8621          * Loop until no more fragments
8622          */
8623
8624         while (trn_data < input_vec_len) {
8625                 ++segs;
8626                 to_trn = (input_vec_len - trn_data < fragsz) ?
8627                                 (input_vec_len - trn_data) : fragsz;
8628
8629                 to_trn_tbl[ecx++] = to_trn;
8630
8631                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
8632                 buf = buf->next;
8633
8634                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
8635                                 rte_pktmbuf_tailroom(buf));
8636
8637                 /* OOP */
8638                 if (oop && !fragsz_oop) {
8639                         buf_oop->next =
8640                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
8641                         buf_oop = buf_oop->next;
8642                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8643                                         0, rte_pktmbuf_tailroom(buf_oop));
8644                         rte_pktmbuf_append(buf_oop, to_trn);
8645                 }
8646
8647                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
8648                                 to_trn);
8649
8650                 memcpy(plaintext, input_vec + trn_data, to_trn);
8651                 trn_data += to_trn;
8652         }
8653
8654         ut_params->ibuf->nb_segs = segs;
8655
8656         segs = 1;
8657         if (fragsz_oop && oop) {
8658                 to_trn = 0;
8659                 ecx = 0;
8660
8661                 trn_data = frag_size_oop;
8662                 while (trn_data < output_vec_len) {
8663                         ++segs;
8664                         to_trn =
8665                                 (output_vec_len - trn_data <
8666                                                 frag_size_oop) ?
8667                                 (output_vec_len - trn_data) :
8668                                                 frag_size_oop;
8669
8670                         to_trn_tbl[ecx++] = to_trn;
8671
8672                         buf_oop->next =
8673                                 rte_pktmbuf_alloc(ts_params->mbuf_pool);
8674                         buf_oop = buf_oop->next;
8675                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
8676                                         0, rte_pktmbuf_tailroom(buf_oop));
8677                         rte_pktmbuf_append(buf_oop, to_trn);
8678
8679                         trn_data += to_trn;
8680                 }
8681                 ut_params->obuf->nb_segs = segs;
8682         }
8683
8684         /* Setup Cipher Parameters */
8685         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
8686         ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
8687         ut_params->cipher_xform.cipher.op = opc;
8688         ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
8689         ut_params->cipher_xform.cipher.key.length =
8690                                         pdcp_test_params[i].cipher_key_len;
8691         ut_params->cipher_xform.cipher.iv.length = 0;
8692
8693         /* Setup HMAC Parameters if ICV header is required */
8694         if (pdcp_test_params[i].auth_alg != 0) {
8695                 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
8696                 ut_params->auth_xform.next = NULL;
8697                 ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
8698                 ut_params->auth_xform.auth.op = opa;
8699                 ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
8700                 ut_params->auth_xform.auth.key.length =
8701                                         pdcp_test_params[i].auth_key_len;
8702
8703                 ut_params->cipher_xform.next = &ut_params->auth_xform;
8704         } else {
8705                 ut_params->cipher_xform.next = NULL;
8706         }
8707
8708         struct rte_security_session_conf sess_conf = {
8709                 .action_type = ut_params->type,
8710                 .protocol = RTE_SECURITY_PROTOCOL_PDCP,
8711                 {.pdcp = {
8712                         .bearer = pdcp_test_bearer[i],
8713                         .domain = pdcp_test_params[i].domain,
8714                         .pkt_dir = pdcp_test_packet_direction[i],
8715                         .sn_size = pdcp_test_data_sn_size[i],
8716                         .hfn = pdcp_test_hfn[i],
8717                         .hfn_threshold = pdcp_test_hfn_threshold[i],
8718                         .hfn_ovrd = 0,
8719                 } },
8720                 .crypto_xform = &ut_params->cipher_xform
8721         };
8722
8723         /* Create security session */
8724         ut_params->sec_session = rte_security_session_create(ctx,
8725                                 &sess_conf, ts_params->session_mpool,
8726                                 ts_params->session_priv_mpool);
8727
8728         if (!ut_params->sec_session) {
8729                 printf("TestCase %s()-%d line %d failed %s: ",
8730                         __func__, i, __LINE__, "Failed to allocate session");
8731                 ret = TEST_FAILED;
8732                 goto on_err;
8733         }
8734
8735         /* Generate crypto op data structure */
8736         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
8737                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
8738         if (!ut_params->op) {
8739                 printf("TestCase %s()-%d line %d failed %s: ",
8740                         __func__, i, __LINE__,
8741                         "Failed to allocate symmetric crypto operation struct");
8742                 ret = TEST_FAILED;
8743                 goto on_err;
8744         }
8745
8746         rte_security_attach_session(ut_params->op, ut_params->sec_session);
8747
8748         /* set crypto operation source mbuf */
8749         ut_params->op->sym->m_src = ut_params->ibuf;
8750         if (oop)
8751                 ut_params->op->sym->m_dst = ut_params->obuf;
8752
8753         /* Process crypto operation */
8754         temp_mbuf = ut_params->op->sym->m_src;
8755         if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
8756                 /* filling lengths */
8757                 while (temp_mbuf) {
8758                         ut_params->op->sym->cipher.data.length
8759                                 += temp_mbuf->pkt_len;
8760                         ut_params->op->sym->auth.data.length
8761                                 += temp_mbuf->pkt_len;
8762                         temp_mbuf = temp_mbuf->next;
8763                 }
8764                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
8765                         ut_params->op, 1, 1, 0, 0);
8766         } else {
8767                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
8768                                                         ut_params->op);
8769         }
8770         if (ut_params->op == NULL) {
8771                 printf("TestCase %s()-%d line %d failed %s: ",
8772                         __func__, i, __LINE__,
8773                         "failed to process sym crypto op");
8774                 ret = TEST_FAILED;
8775                 goto on_err;
8776         }
8777
8778         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
8779                 printf("TestCase %s()-%d line %d failed %s: ",
8780                         __func__, i, __LINE__, "crypto op processing failed");
8781                 ret = TEST_FAILED;
8782                 goto on_err;
8783         }
8784
8785         /* Validate obuf */
8786         uint8_t *ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_src,
8787                         uint8_t *);
8788         if (oop) {
8789                 ciphertext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
8790                                 uint8_t *);
8791         }
8792         if (fragsz_oop)
8793                 fragsz = frag_size_oop;
8794         if (memcmp(ciphertext, output_vec, fragsz)) {
8795                 printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8796                 rte_hexdump(stdout, "encrypted", ciphertext, fragsz);
8797                 rte_hexdump(stdout, "reference", output_vec, fragsz);
8798                 ret = TEST_FAILED;
8799                 goto on_err;
8800         }
8801
8802         buf = ut_params->op->sym->m_src->next;
8803         if (oop)
8804                 buf = ut_params->op->sym->m_dst->next;
8805
8806         unsigned int off = fragsz;
8807
8808         ecx = 0;
8809         while (buf) {
8810                 ciphertext = rte_pktmbuf_mtod(buf,
8811                                 uint8_t *);
8812                 if (memcmp(ciphertext, output_vec + off, to_trn_tbl[ecx])) {
8813                         printf("\n=======PDCP TestCase #%d failed: Data Mismatch ", i);
8814                         rte_hexdump(stdout, "encrypted", ciphertext, to_trn_tbl[ecx]);
8815                         rte_hexdump(stdout, "reference", output_vec + off,
8816                                         to_trn_tbl[ecx]);
8817                         ret = TEST_FAILED;
8818                         goto on_err;
8819                 }
8820                 off += to_trn_tbl[ecx++];
8821                 buf = buf->next;
8822         }
8823 on_err:
8824         rte_crypto_op_free(ut_params->op);
8825         ut_params->op = NULL;
8826
8827         if (ut_params->sec_session)
8828                 rte_security_session_destroy(ctx, ut_params->sec_session);
8829         ut_params->sec_session = NULL;
8830
8831         rte_pktmbuf_free(ut_params->ibuf);
8832         ut_params->ibuf = NULL;
8833         if (oop) {
8834                 rte_pktmbuf_free(ut_params->obuf);
8835                 ut_params->obuf = NULL;
8836         }
8837
8838         return ret;
8839 }
8840
8841 int
8842 test_pdcp_proto_cplane_encap(int i)
8843 {
8844         return test_pdcp_proto(
8845                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8846                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8847                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8848                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8849                 pdcp_test_params[i].cipher_key_len,
8850                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8851                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8852                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8853                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8854                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8855 }
8856
8857 int
8858 test_pdcp_proto_uplane_encap(int i)
8859 {
8860         return test_pdcp_proto(
8861                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8862                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8863                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8864                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8865                 pdcp_test_params[i].cipher_key_len,
8866                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8867                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8868                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8869                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8870                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8871 }
8872
8873 int
8874 test_pdcp_proto_uplane_encap_with_int(int i)
8875 {
8876         return test_pdcp_proto(
8877                 i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
8878                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8879                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8880                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8881                 pdcp_test_params[i].cipher_key_len,
8882                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8883                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8884                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8885                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8886                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8887 }
8888
8889 int
8890 test_pdcp_proto_cplane_decap(int i)
8891 {
8892         return test_pdcp_proto(
8893                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8894                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8895                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8896                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8897                 pdcp_test_params[i].cipher_key_len,
8898                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8899                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8900                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8901                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8902                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8903 }
8904
8905 int
8906 test_pdcp_proto_uplane_decap(int i)
8907 {
8908         return test_pdcp_proto(
8909                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8910                 pdcp_test_data_out[i], pdcp_test_data_in_len[i],
8911                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8912                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8913                 pdcp_test_params[i].cipher_key_len,
8914                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8915                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8916                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8917                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8918                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8919 }
8920
8921 int
8922 test_pdcp_proto_uplane_decap_with_int(int i)
8923 {
8924         return test_pdcp_proto(
8925                 i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
8926                 pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
8927                 pdcp_test_data_in[i], pdcp_test_data_in_len[i],
8928                 pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
8929                 pdcp_test_params[i].cipher_key_len,
8930                 pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
8931                 pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
8932                 pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
8933                 pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
8934                 pdcp_test_hfn_threshold[i], SDAP_DISABLED);
8935 }
8936
8937 static int
8938 test_PDCP_PROTO_SGL_in_place_32B(void)
8939 {
8940         /* i can be used for running any PDCP case
8941          * In this case it is uplane 12-bit AES-SNOW DL encap
8942          */
8943         int i = PDCP_UPLANE_12BIT_OFFSET + AES_ENC + SNOW_AUTH + DOWNLINK;
8944         return test_pdcp_proto_SGL(i, IN_PLACE,
8945                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8946                         RTE_CRYPTO_AUTH_OP_GENERATE,
8947                         pdcp_test_data_in[i],
8948                         pdcp_test_data_in_len[i],
8949                         pdcp_test_data_out[i],
8950                         pdcp_test_data_in_len[i]+4,
8951                         32, 0);
8952 }
8953 static int
8954 test_PDCP_PROTO_SGL_oop_32B_128B(void)
8955 {
8956         /* i can be used for running any PDCP case
8957          * In this case it is uplane 18-bit NULL-NULL DL encap
8958          */
8959         int i = PDCP_UPLANE_18BIT_OFFSET + NULL_ENC + NULL_AUTH + DOWNLINK;
8960         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8961                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8962                         RTE_CRYPTO_AUTH_OP_GENERATE,
8963                         pdcp_test_data_in[i],
8964                         pdcp_test_data_in_len[i],
8965                         pdcp_test_data_out[i],
8966                         pdcp_test_data_in_len[i]+4,
8967                         32, 128);
8968 }
8969 static int
8970 test_PDCP_PROTO_SGL_oop_32B_40B(void)
8971 {
8972         /* i can be used for running any PDCP case
8973          * In this case it is uplane 18-bit AES DL encap
8974          */
8975         int i = PDCP_UPLANE_OFFSET + AES_ENC + EIGHTEEN_BIT_SEQ_NUM_OFFSET
8976                         + DOWNLINK;
8977         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8978                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8979                         RTE_CRYPTO_AUTH_OP_GENERATE,
8980                         pdcp_test_data_in[i],
8981                         pdcp_test_data_in_len[i],
8982                         pdcp_test_data_out[i],
8983                         pdcp_test_data_in_len[i],
8984                         32, 40);
8985 }
8986 static int
8987 test_PDCP_PROTO_SGL_oop_128B_32B(void)
8988 {
8989         /* i can be used for running any PDCP case
8990          * In this case it is cplane 12-bit AES-ZUC DL encap
8991          */
8992         int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK;
8993         return test_pdcp_proto_SGL(i, OUT_OF_PLACE,
8994                         RTE_CRYPTO_CIPHER_OP_ENCRYPT,
8995                         RTE_CRYPTO_AUTH_OP_GENERATE,
8996                         pdcp_test_data_in[i],
8997                         pdcp_test_data_in_len[i],
8998                         pdcp_test_data_out[i],
8999                         pdcp_test_data_in_len[i]+4,
9000                         128, 32);
9001 }
9002
9003 static int
9004 test_PDCP_SDAP_PROTO_encap_all(void)
9005 {
9006         int i = 0, size = 0;
9007         int err, all_err = TEST_SUCCESS;
9008         const struct pdcp_sdap_test *cur_test;
9009
9010         size = RTE_DIM(list_pdcp_sdap_tests);
9011
9012         for (i = 0; i < size; i++) {
9013                 cur_test = &list_pdcp_sdap_tests[i];
9014                 err = test_pdcp_proto(
9015                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9016                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9017                         cur_test->in_len, cur_test->data_out,
9018                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9019                         cur_test->param.cipher_alg, cur_test->cipher_key,
9020                         cur_test->param.cipher_key_len,
9021                         cur_test->param.auth_alg,
9022                         cur_test->auth_key, cur_test->param.auth_key_len,
9023                         cur_test->bearer, cur_test->param.domain,
9024                         cur_test->packet_direction, cur_test->sn_size,
9025                         cur_test->hfn,
9026                         cur_test->hfn_threshold, SDAP_ENABLED);
9027                 if (err) {
9028                         printf("\t%d) %s: Encapsulation failed\n",
9029                                         cur_test->test_idx,
9030                                         cur_test->param.name);
9031                         err = TEST_FAILED;
9032                 } else {
9033                         printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
9034                                         cur_test->param.name);
9035                         err = TEST_SUCCESS;
9036                 }
9037                 all_err += err;
9038         }
9039
9040         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9041
9042         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9043 }
9044
9045 static int
9046 test_PDCP_PROTO_short_mac(void)
9047 {
9048         int i = 0, size = 0;
9049         int err, all_err = TEST_SUCCESS;
9050         const struct pdcp_short_mac_test *cur_test;
9051
9052         size = RTE_DIM(list_pdcp_smac_tests);
9053
9054         for (i = 0; i < size; i++) {
9055                 cur_test = &list_pdcp_smac_tests[i];
9056                 err = test_pdcp_proto(
9057                         i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
9058                         RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
9059                         cur_test->in_len, cur_test->data_out,
9060                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9061                         RTE_CRYPTO_CIPHER_NULL, NULL,
9062                         0, cur_test->param.auth_alg,
9063                         cur_test->auth_key, cur_test->param.auth_key_len,
9064                         0, cur_test->param.domain, 0, 0,
9065                         0, 0, 0);
9066                 if (err) {
9067                         printf("\t%d) %s: Short MAC test failed\n",
9068                                         cur_test->test_idx,
9069                                         cur_test->param.name);
9070                         err = TEST_FAILED;
9071                 } else {
9072                         printf("\t%d) %s: Short MAC test PASS\n",
9073                                         cur_test->test_idx,
9074                                         cur_test->param.name);
9075                         rte_hexdump(stdout, "MAC I",
9076                                     cur_test->data_out + cur_test->in_len + 2,
9077                                     2);
9078                         err = TEST_SUCCESS;
9079                 }
9080                 all_err += err;
9081         }
9082
9083         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9084
9085         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9086
9087 }
9088
9089 static int
9090 test_PDCP_SDAP_PROTO_decap_all(void)
9091 {
9092         int i = 0, size = 0;
9093         int err, all_err = TEST_SUCCESS;
9094         const struct pdcp_sdap_test *cur_test;
9095
9096         size = RTE_DIM(list_pdcp_sdap_tests);
9097
9098         for (i = 0; i < size; i++) {
9099                 cur_test = &list_pdcp_sdap_tests[i];
9100                 err = test_pdcp_proto(
9101                         i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
9102                         RTE_CRYPTO_AUTH_OP_VERIFY,
9103                         cur_test->data_out,
9104                         cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
9105                         cur_test->data_in, cur_test->in_len,
9106                         cur_test->param.cipher_alg,
9107                         cur_test->cipher_key, cur_test->param.cipher_key_len,
9108                         cur_test->param.auth_alg, cur_test->auth_key,
9109                         cur_test->param.auth_key_len, cur_test->bearer,
9110                         cur_test->param.domain, cur_test->packet_direction,
9111                         cur_test->sn_size, cur_test->hfn,
9112                         cur_test->hfn_threshold, SDAP_ENABLED);
9113                 if (err) {
9114                         printf("\t%d) %s: Decapsulation failed\n",
9115                                         cur_test->test_idx,
9116                                         cur_test->param.name);
9117                         err = TEST_FAILED;
9118                 } else {
9119                         printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
9120                                         cur_test->param.name);
9121                         err = TEST_SUCCESS;
9122                 }
9123                 all_err += err;
9124         }
9125
9126         printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
9127
9128         return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
9129 }
9130
9131 static int
9132 test_ipsec_proto_process(const struct ipsec_test_data td[],
9133                          struct ipsec_test_data res_d[],
9134                          int nb_td,
9135                          bool silent,
9136                          const struct ipsec_test_flags *flags)
9137 {
9138         uint16_t v6_src[8] = {0x2607, 0xf8b0, 0x400c, 0x0c03, 0x0000, 0x0000,
9139                                 0x0000, 0x001a};
9140         uint16_t v6_dst[8] = {0x2001, 0x0470, 0xe5bf, 0xdead, 0x4957, 0x2174,
9141                                 0xe82c, 0x4887};
9142         struct crypto_testsuite_params *ts_params = &testsuite_params;
9143         struct crypto_unittest_params *ut_params = &unittest_params;
9144         struct rte_security_capability_idx sec_cap_idx;
9145         const struct rte_security_capability *sec_cap;
9146         struct rte_security_ipsec_xform ipsec_xform;
9147         uint8_t dev_id = ts_params->valid_devs[0];
9148         enum rte_security_ipsec_sa_direction dir;
9149         struct ipsec_test_data *res_d_tmp = NULL;
9150         uint32_t src = RTE_IPV4(192, 168, 1, 0);
9151         uint32_t dst = RTE_IPV4(192, 168, 1, 1);
9152         int salt_len, i, ret = TEST_SUCCESS;
9153         struct rte_security_ctx *ctx;
9154         uint8_t *input_text;
9155         uint32_t verify;
9156
9157         ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9158         gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL;
9159
9160         /* Use first test data to create session */
9161
9162         /* Copy IPsec xform */
9163         memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform));
9164
9165         dir = ipsec_xform.direction;
9166         verify = flags->tunnel_hdr_verify;
9167
9168         if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) {
9169                 if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR)
9170                         src += 1;
9171                 else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR)
9172                         dst += 1;
9173         }
9174
9175         if (td->ipsec_xform.mode == RTE_SECURITY_IPSEC_SA_MODE_TUNNEL) {
9176                 if (td->ipsec_xform.tunnel.type ==
9177                                 RTE_SECURITY_IPSEC_TUNNEL_IPV4) {
9178                         memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src,
9179                                sizeof(src));
9180                         memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst,
9181                                sizeof(dst));
9182
9183                         if (flags->df == TEST_IPSEC_SET_DF_0_INNER_1)
9184                                 ipsec_xform.tunnel.ipv4.df = 0;
9185
9186                         if (flags->df == TEST_IPSEC_SET_DF_1_INNER_0)
9187                                 ipsec_xform.tunnel.ipv4.df = 1;
9188
9189                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9190                                 ipsec_xform.tunnel.ipv4.dscp = 0;
9191
9192                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9193                                 ipsec_xform.tunnel.ipv4.dscp =
9194                                                 TEST_IPSEC_DSCP_VAL;
9195
9196                 } else {
9197                         if (flags->dscp == TEST_IPSEC_SET_DSCP_0_INNER_1)
9198                                 ipsec_xform.tunnel.ipv6.dscp = 0;
9199
9200                         if (flags->dscp == TEST_IPSEC_SET_DSCP_1_INNER_0)
9201                                 ipsec_xform.tunnel.ipv6.dscp =
9202                                                 TEST_IPSEC_DSCP_VAL;
9203
9204                         memcpy(&ipsec_xform.tunnel.ipv6.src_addr, &v6_src,
9205                                sizeof(v6_src));
9206                         memcpy(&ipsec_xform.tunnel.ipv6.dst_addr, &v6_dst,
9207                                sizeof(v6_dst));
9208                 }
9209         }
9210
9211         ctx = rte_cryptodev_get_sec_ctx(dev_id);
9212
9213         sec_cap_idx.action = ut_params->type;
9214         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC;
9215         sec_cap_idx.ipsec.proto = ipsec_xform.proto;
9216         sec_cap_idx.ipsec.mode = ipsec_xform.mode;
9217         sec_cap_idx.ipsec.direction = ipsec_xform.direction;
9218
9219         if (flags->udp_encap)
9220                 ipsec_xform.options.udp_encap = 1;
9221
9222         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
9223         if (sec_cap == NULL)
9224                 return TEST_SKIPPED;
9225
9226         /* Copy cipher session parameters */
9227         if (td[0].aead) {
9228                 memcpy(&ut_params->aead_xform, &td[0].xform.aead,
9229                        sizeof(ut_params->aead_xform));
9230                 ut_params->aead_xform.aead.key.data = td[0].key.data;
9231                 ut_params->aead_xform.aead.iv.offset = IV_OFFSET;
9232
9233                 /* Verify crypto capabilities */
9234                 if (test_ipsec_crypto_caps_aead_verify(
9235                                 sec_cap,
9236                                 &ut_params->aead_xform) != 0) {
9237                         if (!silent)
9238                                 RTE_LOG(INFO, USER1,
9239                                         "Crypto capabilities not supported\n");
9240                         return TEST_SKIPPED;
9241                 }
9242         } else if (td[0].auth_only) {
9243                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9244                        sizeof(ut_params->auth_xform));
9245                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9246
9247                 if (test_ipsec_crypto_caps_auth_verify(
9248                                 sec_cap,
9249                                 &ut_params->auth_xform) != 0) {
9250                         if (!silent)
9251                                 RTE_LOG(INFO, USER1,
9252                                         "Auth crypto capabilities not supported\n");
9253                         return TEST_SKIPPED;
9254                 }
9255         } else {
9256                 memcpy(&ut_params->cipher_xform, &td[0].xform.chain.cipher,
9257                        sizeof(ut_params->cipher_xform));
9258                 memcpy(&ut_params->auth_xform, &td[0].xform.chain.auth,
9259                        sizeof(ut_params->auth_xform));
9260                 ut_params->cipher_xform.cipher.key.data = td[0].key.data;
9261                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
9262                 ut_params->auth_xform.auth.key.data = td[0].auth_key.data;
9263
9264                 /* Verify crypto capabilities */
9265
9266                 if (test_ipsec_crypto_caps_cipher_verify(
9267                                 sec_cap,
9268                                 &ut_params->cipher_xform) != 0) {
9269                         if (!silent)
9270                                 RTE_LOG(INFO, USER1,
9271                                         "Cipher crypto capabilities not supported\n");
9272                         return TEST_SKIPPED;
9273                 }
9274
9275                 if (test_ipsec_crypto_caps_auth_verify(
9276                                 sec_cap,
9277                                 &ut_params->auth_xform) != 0) {
9278                         if (!silent)
9279                                 RTE_LOG(INFO, USER1,
9280                                         "Auth crypto capabilities not supported\n");
9281                         return TEST_SKIPPED;
9282                 }
9283         }
9284
9285         if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0)
9286                 return TEST_SKIPPED;
9287
9288         struct rte_security_session_conf sess_conf = {
9289                 .action_type = ut_params->type,
9290                 .protocol = RTE_SECURITY_PROTOCOL_IPSEC,
9291         };
9292
9293         if (td[0].aead) {
9294                 salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len);
9295                 memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len);
9296                 sess_conf.ipsec = ipsec_xform;
9297                 sess_conf.crypto_xform = &ut_params->aead_xform;
9298         } else if (td[0].auth_only) {
9299                 sess_conf.ipsec = ipsec_xform;
9300                 sess_conf.crypto_xform = &ut_params->auth_xform;
9301         } else {
9302                 sess_conf.ipsec = ipsec_xform;
9303                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS) {
9304                         sess_conf.crypto_xform = &ut_params->cipher_xform;
9305                         ut_params->cipher_xform.next = &ut_params->auth_xform;
9306                 } else {
9307                         sess_conf.crypto_xform = &ut_params->auth_xform;
9308                         ut_params->auth_xform.next = &ut_params->cipher_xform;
9309                 }
9310         }
9311
9312         /* Create security session */
9313         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
9314                                         ts_params->session_mpool,
9315                                         ts_params->session_priv_mpool);
9316
9317         if (ut_params->sec_session == NULL)
9318                 return TEST_SKIPPED;
9319
9320         for (i = 0; i < nb_td; i++) {
9321                 if (flags->antireplay &&
9322                     (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)) {
9323                         sess_conf.ipsec.esn.value = td[i].ipsec_xform.esn.value;
9324                         ret = rte_security_session_update(ctx,
9325                                 ut_params->sec_session, &sess_conf);
9326                         if (ret) {
9327                                 printf("Could not update sequence number in "
9328                                        "session\n");
9329                                 return TEST_SKIPPED;
9330                         }
9331                 }
9332
9333                 /* Setup source mbuf payload */
9334                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
9335                 memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
9336                                 rte_pktmbuf_tailroom(ut_params->ibuf));
9337
9338                 input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
9339                                 td[i].input_text.len);
9340
9341                 memcpy(input_text, td[i].input_text.data,
9342                        td[i].input_text.len);
9343
9344                 if (test_ipsec_pkt_update(input_text, flags))
9345                         return TEST_FAILED;
9346
9347                 /* Generate crypto op data structure */
9348                 ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
9349                                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
9350                 if (!ut_params->op) {
9351                         printf("TestCase %s line %d: %s\n",
9352                                 __func__, __LINE__,
9353                                 "failed to allocate crypto op");
9354                         ret = TEST_FAILED;
9355                         goto crypto_op_free;
9356                 }
9357
9358                 /* Attach session to operation */
9359                 rte_security_attach_session(ut_params->op,
9360                                             ut_params->sec_session);
9361
9362                 /* Set crypto operation mbufs */
9363                 ut_params->op->sym->m_src = ut_params->ibuf;
9364                 ut_params->op->sym->m_dst = NULL;
9365
9366                 /* Copy IV in crypto operation when IV generation is disabled */
9367                 if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS &&
9368                     ipsec_xform.options.iv_gen_disable == 1) {
9369                         uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op,
9370                                                                 uint8_t *,
9371                                                                 IV_OFFSET);
9372                         int len;
9373
9374                         if (td[i].aead)
9375                                 len = td[i].xform.aead.aead.iv.length;
9376                         else
9377                                 len = td[i].xform.chain.cipher.cipher.iv.length;
9378
9379                         memcpy(iv, td[i].iv.data, len);
9380                 }
9381
9382                 /* Process crypto operation */
9383                 process_crypto_request(dev_id, ut_params->op);
9384
9385                 ret = test_ipsec_status_check(&td[i], ut_params->op, flags, dir,
9386                                               i + 1);
9387                 if (ret != TEST_SUCCESS)
9388                         goto crypto_op_free;
9389
9390                 if (res_d != NULL)
9391                         res_d_tmp = &res_d[i];
9392
9393                 ret = test_ipsec_post_process(ut_params->ibuf, &td[i],
9394                                               res_d_tmp, silent, flags);
9395                 if (ret != TEST_SUCCESS)
9396                         goto crypto_op_free;
9397
9398                 ret = test_ipsec_stats_verify(ctx, ut_params->sec_session,
9399                                               flags, dir);
9400                 if (ret != TEST_SUCCESS)
9401                         goto crypto_op_free;
9402
9403                 rte_crypto_op_free(ut_params->op);
9404                 ut_params->op = NULL;
9405
9406                 rte_pktmbuf_free(ut_params->ibuf);
9407                 ut_params->ibuf = NULL;
9408         }
9409
9410 crypto_op_free:
9411         rte_crypto_op_free(ut_params->op);
9412         ut_params->op = NULL;
9413
9414         rte_pktmbuf_free(ut_params->ibuf);
9415         ut_params->ibuf = NULL;
9416
9417         if (ut_params->sec_session)
9418                 rte_security_session_destroy(ctx, ut_params->sec_session);
9419         ut_params->sec_session = NULL;
9420
9421         return ret;
9422 }
9423
9424 static int
9425 test_ipsec_proto_known_vec(const void *test_data)
9426 {
9427         struct ipsec_test_data td_outb;
9428         struct ipsec_test_flags flags;
9429
9430         memset(&flags, 0, sizeof(flags));
9431
9432         memcpy(&td_outb, test_data, sizeof(td_outb));
9433
9434         if (td_outb.aead ||
9435             td_outb.xform.chain.cipher.cipher.algo != RTE_CRYPTO_CIPHER_NULL) {
9436                 /* Disable IV gen to be able to test with known vectors */
9437                 td_outb.ipsec_xform.options.iv_gen_disable = 1;
9438         }
9439
9440         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9441 }
9442
9443 static int
9444 test_ipsec_proto_known_vec_inb(const void *test_data)
9445 {
9446         const struct ipsec_test_data *td = test_data;
9447         struct ipsec_test_flags flags;
9448         struct ipsec_test_data td_inb;
9449
9450         memset(&flags, 0, sizeof(flags));
9451
9452         if (td->ipsec_xform.direction == RTE_SECURITY_IPSEC_SA_DIR_EGRESS)
9453                 test_ipsec_td_in_from_out(td, &td_inb);
9454         else
9455                 memcpy(&td_inb, td, sizeof(td_inb));
9456
9457         return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags);
9458 }
9459
9460 static int
9461 test_ipsec_proto_known_vec_fragmented(const void *test_data)
9462 {
9463         struct ipsec_test_data td_outb;
9464         struct ipsec_test_flags flags;
9465
9466         memset(&flags, 0, sizeof(flags));
9467         flags.fragment = true;
9468
9469         memcpy(&td_outb, test_data, sizeof(td_outb));
9470
9471         /* Disable IV gen to be able to test with known vectors */
9472         td_outb.ipsec_xform.options.iv_gen_disable = 1;
9473
9474         return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags);
9475 }
9476
9477 static int
9478 test_ipsec_proto_all(const struct ipsec_test_flags *flags)
9479 {
9480         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9481         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9482         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9483         int ret;
9484
9485         if (flags->iv_gen ||
9486             flags->sa_expiry_pkts_soft ||
9487             flags->sa_expiry_pkts_hard)
9488                 nb_pkts = IPSEC_TEST_PACKETS_MAX;
9489
9490         for (i = 0; i < RTE_DIM(alg_list); i++) {
9491                 test_ipsec_td_prepare(alg_list[i].param1,
9492                                       alg_list[i].param2,
9493                                       flags,
9494                                       td_outb,
9495                                       nb_pkts);
9496
9497                 if (!td_outb->aead) {
9498                         enum rte_crypto_cipher_algorithm cipher_alg;
9499                         enum rte_crypto_auth_algorithm auth_alg;
9500
9501                         cipher_alg = td_outb->xform.chain.cipher.cipher.algo;
9502                         auth_alg = td_outb->xform.chain.auth.auth.algo;
9503
9504                         /* ICV is not applicable for NULL auth */
9505                         if (flags->icv_corrupt &&
9506                             auth_alg == RTE_CRYPTO_AUTH_NULL)
9507                                 continue;
9508
9509                         /* IV is not applicable for NULL cipher */
9510                         if (flags->iv_gen &&
9511                             cipher_alg == RTE_CRYPTO_CIPHER_NULL)
9512                                 continue;
9513                 }
9514
9515                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9516                                                flags);
9517                 if (ret == TEST_SKIPPED)
9518                         continue;
9519
9520                 if (ret == TEST_FAILED)
9521                         return TEST_FAILED;
9522
9523                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9524
9525                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9526                                                flags);
9527                 if (ret == TEST_SKIPPED)
9528                         continue;
9529
9530                 if (ret == TEST_FAILED)
9531                         return TEST_FAILED;
9532
9533                 if (flags->display_alg)
9534                         test_ipsec_display_alg(alg_list[i].param1,
9535                                                alg_list[i].param2);
9536
9537                 pass_cnt++;
9538         }
9539
9540         if (pass_cnt > 0)
9541                 return TEST_SUCCESS;
9542         else
9543                 return TEST_SKIPPED;
9544 }
9545
9546 static int
9547 test_ipsec_ah_proto_all(const struct ipsec_test_flags *flags)
9548 {
9549         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
9550         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
9551         unsigned int i, nb_pkts = 1, pass_cnt = 0;
9552         int ret;
9553
9554         for (i = 0; i < RTE_DIM(ah_alg_list); i++) {
9555                 test_ipsec_td_prepare(ah_alg_list[i].param1,
9556                                       ah_alg_list[i].param2,
9557                                       flags,
9558                                       td_outb,
9559                                       nb_pkts);
9560
9561                 ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
9562                                                flags);
9563                 if (ret == TEST_SKIPPED)
9564                         continue;
9565
9566                 if (ret == TEST_FAILED)
9567                         return TEST_FAILED;
9568
9569                 test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags);
9570
9571                 ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
9572                                                flags);
9573                 if (ret == TEST_SKIPPED)
9574                         continue;
9575
9576                 if (ret == TEST_FAILED)
9577                         return TEST_FAILED;
9578
9579                 if (flags->display_alg)
9580                         test_ipsec_display_alg(ah_alg_list[i].param1,
9581                                                ah_alg_list[i].param2);
9582
9583                 pass_cnt++;
9584         }
9585
9586         if (pass_cnt > 0)
9587                 return TEST_SUCCESS;
9588         else
9589                 return TEST_SKIPPED;
9590 }
9591
9592 static int
9593 test_ipsec_proto_display_list(const void *data __rte_unused)
9594 {
9595         struct ipsec_test_flags flags;
9596
9597         memset(&flags, 0, sizeof(flags));
9598
9599         flags.display_alg = true;
9600
9601         return test_ipsec_proto_all(&flags);
9602 }
9603
9604 static int
9605 test_ipsec_proto_ah_tunnel_ipv4(const void *data __rte_unused)
9606 {
9607         struct ipsec_test_flags flags;
9608
9609         memset(&flags, 0, sizeof(flags));
9610
9611         flags.ah = true;
9612         flags.display_alg = true;
9613
9614         return test_ipsec_ah_proto_all(&flags);
9615 }
9616
9617 static int
9618 test_ipsec_proto_ah_transport_ipv4(const void *data __rte_unused)
9619 {
9620         struct ipsec_test_flags flags;
9621
9622         memset(&flags, 0, sizeof(flags));
9623
9624         flags.ah = true;
9625         flags.transport = true;
9626
9627         return test_ipsec_ah_proto_all(&flags);
9628 }
9629
9630 static int
9631 test_ipsec_proto_iv_gen(const void *data __rte_unused)
9632 {
9633         struct ipsec_test_flags flags;
9634
9635         memset(&flags, 0, sizeof(flags));
9636
9637         flags.iv_gen = true;
9638
9639         return test_ipsec_proto_all(&flags);
9640 }
9641
9642 static int
9643 test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused)
9644 {
9645         struct ipsec_test_flags flags;
9646
9647         memset(&flags, 0, sizeof(flags));
9648
9649         flags.sa_expiry_pkts_soft = true;
9650
9651         return test_ipsec_proto_all(&flags);
9652 }
9653
9654 static int
9655 test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused)
9656 {
9657         struct ipsec_test_flags flags;
9658
9659         memset(&flags, 0, sizeof(flags));
9660
9661         flags.sa_expiry_pkts_hard = true;
9662
9663         return test_ipsec_proto_all(&flags);
9664 }
9665
9666 static int
9667 test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused)
9668 {
9669         struct ipsec_test_flags flags;
9670
9671         memset(&flags, 0, sizeof(flags));
9672
9673         flags.icv_corrupt = true;
9674
9675         return test_ipsec_proto_all(&flags);
9676 }
9677
9678 static int
9679 test_ipsec_proto_udp_encap(const void *data __rte_unused)
9680 {
9681         struct ipsec_test_flags flags;
9682
9683         memset(&flags, 0, sizeof(flags));
9684
9685         flags.udp_encap = true;
9686
9687         return test_ipsec_proto_all(&flags);
9688 }
9689
9690 static int
9691 test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused)
9692 {
9693         struct ipsec_test_flags flags;
9694
9695         memset(&flags, 0, sizeof(flags));
9696
9697         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR;
9698
9699         return test_ipsec_proto_all(&flags);
9700 }
9701
9702 static int
9703 test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused)
9704 {
9705         struct ipsec_test_flags flags;
9706
9707         memset(&flags, 0, sizeof(flags));
9708
9709         flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR;
9710
9711         return test_ipsec_proto_all(&flags);
9712 }
9713
9714 static int
9715 test_ipsec_proto_udp_ports_verify(const void *data __rte_unused)
9716 {
9717         struct ipsec_test_flags flags;
9718
9719         memset(&flags, 0, sizeof(flags));
9720
9721         flags.udp_encap = true;
9722         flags.udp_ports_verify = true;
9723
9724         return test_ipsec_proto_all(&flags);
9725 }
9726
9727 static int
9728 test_ipsec_proto_inner_ip_csum(const void *data __rte_unused)
9729 {
9730         struct ipsec_test_flags flags;
9731
9732         memset(&flags, 0, sizeof(flags));
9733
9734         flags.ip_csum = true;
9735
9736         return test_ipsec_proto_all(&flags);
9737 }
9738
9739 static int
9740 test_ipsec_proto_inner_l4_csum(const void *data __rte_unused)
9741 {
9742         struct ipsec_test_flags flags;
9743
9744         memset(&flags, 0, sizeof(flags));
9745
9746         flags.l4_csum = true;
9747
9748         return test_ipsec_proto_all(&flags);
9749 }
9750
9751 static int
9752 test_ipsec_proto_tunnel_v4_in_v4(const void *data __rte_unused)
9753 {
9754         struct ipsec_test_flags flags;
9755
9756         memset(&flags, 0, sizeof(flags));
9757
9758         flags.ipv6 = false;
9759         flags.tunnel_ipv6 = false;
9760
9761         return test_ipsec_proto_all(&flags);
9762 }
9763
9764 static int
9765 test_ipsec_proto_tunnel_v6_in_v6(const void *data __rte_unused)
9766 {
9767         struct ipsec_test_flags flags;
9768
9769         memset(&flags, 0, sizeof(flags));
9770
9771         flags.ipv6 = true;
9772         flags.tunnel_ipv6 = true;
9773
9774         return test_ipsec_proto_all(&flags);
9775 }
9776
9777 static int
9778 test_ipsec_proto_tunnel_v4_in_v6(const void *data __rte_unused)
9779 {
9780         struct ipsec_test_flags flags;
9781
9782         memset(&flags, 0, sizeof(flags));
9783
9784         flags.ipv6 = false;
9785         flags.tunnel_ipv6 = true;
9786
9787         return test_ipsec_proto_all(&flags);
9788 }
9789
9790 static int
9791 test_ipsec_proto_tunnel_v6_in_v4(const void *data __rte_unused)
9792 {
9793         struct ipsec_test_flags flags;
9794
9795         memset(&flags, 0, sizeof(flags));
9796
9797         flags.ipv6 = true;
9798         flags.tunnel_ipv6 = false;
9799
9800         return test_ipsec_proto_all(&flags);
9801 }
9802
9803 static int
9804 test_ipsec_proto_transport_v4(const void *data __rte_unused)
9805 {
9806         struct ipsec_test_flags flags;
9807
9808         memset(&flags, 0, sizeof(flags));
9809
9810         flags.ipv6 = false;
9811         flags.transport = true;
9812
9813         return test_ipsec_proto_all(&flags);
9814 }
9815
9816 static int
9817 test_ipsec_proto_transport_l4_csum(const void *data __rte_unused)
9818 {
9819         struct ipsec_test_flags flags = {
9820                 .l4_csum = true,
9821                 .transport = true,
9822         };
9823
9824         return test_ipsec_proto_all(&flags);
9825 }
9826
9827 static int
9828 test_ipsec_proto_stats(const void *data __rte_unused)
9829 {
9830         struct ipsec_test_flags flags;
9831
9832         memset(&flags, 0, sizeof(flags));
9833
9834         flags.stats_success = true;
9835
9836         return test_ipsec_proto_all(&flags);
9837 }
9838
9839 static int
9840 test_ipsec_proto_pkt_fragment(const void *data __rte_unused)
9841 {
9842         struct ipsec_test_flags flags;
9843
9844         memset(&flags, 0, sizeof(flags));
9845
9846         flags.fragment = true;
9847
9848         return test_ipsec_proto_all(&flags);
9849
9850 }
9851
9852 static int
9853 test_ipsec_proto_copy_df_inner_0(const void *data __rte_unused)
9854 {
9855         struct ipsec_test_flags flags;
9856
9857         memset(&flags, 0, sizeof(flags));
9858
9859         flags.df = TEST_IPSEC_COPY_DF_INNER_0;
9860
9861         return test_ipsec_proto_all(&flags);
9862 }
9863
9864 static int
9865 test_ipsec_proto_copy_df_inner_1(const void *data __rte_unused)
9866 {
9867         struct ipsec_test_flags flags;
9868
9869         memset(&flags, 0, sizeof(flags));
9870
9871         flags.df = TEST_IPSEC_COPY_DF_INNER_1;
9872
9873         return test_ipsec_proto_all(&flags);
9874 }
9875
9876 static int
9877 test_ipsec_proto_set_df_0_inner_1(const void *data __rte_unused)
9878 {
9879         struct ipsec_test_flags flags;
9880
9881         memset(&flags, 0, sizeof(flags));
9882
9883         flags.df = TEST_IPSEC_SET_DF_0_INNER_1;
9884
9885         return test_ipsec_proto_all(&flags);
9886 }
9887
9888 static int
9889 test_ipsec_proto_set_df_1_inner_0(const void *data __rte_unused)
9890 {
9891         struct ipsec_test_flags flags;
9892
9893         memset(&flags, 0, sizeof(flags));
9894
9895         flags.df = TEST_IPSEC_SET_DF_1_INNER_0;
9896
9897         return test_ipsec_proto_all(&flags);
9898 }
9899
9900 static int
9901 test_ipsec_proto_ipv4_copy_dscp_inner_0(const void *data __rte_unused)
9902 {
9903         struct ipsec_test_flags flags;
9904
9905         memset(&flags, 0, sizeof(flags));
9906
9907         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9908
9909         return test_ipsec_proto_all(&flags);
9910 }
9911
9912 static int
9913 test_ipsec_proto_ipv4_copy_dscp_inner_1(const void *data __rte_unused)
9914 {
9915         struct ipsec_test_flags flags;
9916
9917         memset(&flags, 0, sizeof(flags));
9918
9919         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9920
9921         return test_ipsec_proto_all(&flags);
9922 }
9923
9924 static int
9925 test_ipsec_proto_ipv4_set_dscp_0_inner_1(const void *data __rte_unused)
9926 {
9927         struct ipsec_test_flags flags;
9928
9929         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9930                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9931                 return TEST_SKIPPED;
9932
9933         memset(&flags, 0, sizeof(flags));
9934
9935         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9936
9937         return test_ipsec_proto_all(&flags);
9938 }
9939
9940 static int
9941 test_ipsec_proto_ipv4_set_dscp_1_inner_0(const void *data __rte_unused)
9942 {
9943         struct ipsec_test_flags flags;
9944
9945         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9946                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9947                 return TEST_SKIPPED;
9948
9949         memset(&flags, 0, sizeof(flags));
9950
9951         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
9952
9953         return test_ipsec_proto_all(&flags);
9954 }
9955
9956 static int
9957 test_ipsec_proto_ipv6_copy_dscp_inner_0(const void *data __rte_unused)
9958 {
9959         struct ipsec_test_flags flags;
9960
9961         memset(&flags, 0, sizeof(flags));
9962
9963         flags.ipv6 = true;
9964         flags.tunnel_ipv6 = true;
9965         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_0;
9966
9967         return test_ipsec_proto_all(&flags);
9968 }
9969
9970 static int
9971 test_ipsec_proto_ipv6_copy_dscp_inner_1(const void *data __rte_unused)
9972 {
9973         struct ipsec_test_flags flags;
9974
9975         memset(&flags, 0, sizeof(flags));
9976
9977         flags.ipv6 = true;
9978         flags.tunnel_ipv6 = true;
9979         flags.dscp = TEST_IPSEC_COPY_DSCP_INNER_1;
9980
9981         return test_ipsec_proto_all(&flags);
9982 }
9983
9984 static int
9985 test_ipsec_proto_ipv6_set_dscp_0_inner_1(const void *data __rte_unused)
9986 {
9987         struct ipsec_test_flags flags;
9988
9989         if (gbl_driver_id == rte_cryptodev_driver_id_get(
9990                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
9991                 return TEST_SKIPPED;
9992
9993         memset(&flags, 0, sizeof(flags));
9994
9995         flags.ipv6 = true;
9996         flags.tunnel_ipv6 = true;
9997         flags.dscp = TEST_IPSEC_SET_DSCP_0_INNER_1;
9998
9999         return test_ipsec_proto_all(&flags);
10000 }
10001
10002 static int
10003 test_ipsec_proto_ipv6_set_dscp_1_inner_0(const void *data __rte_unused)
10004 {
10005         struct ipsec_test_flags flags;
10006
10007         if (gbl_driver_id == rte_cryptodev_driver_id_get(
10008                         RTE_STR(CRYPTODEV_NAME_CN9K_PMD)))
10009                 return TEST_SKIPPED;
10010
10011         memset(&flags, 0, sizeof(flags));
10012
10013         flags.ipv6 = true;
10014         flags.tunnel_ipv6 = true;
10015         flags.dscp = TEST_IPSEC_SET_DSCP_1_INNER_0;
10016
10017         return test_ipsec_proto_all(&flags);
10018 }
10019
10020 static int
10021 test_ipsec_pkt_replay(const void *test_data, const uint64_t esn[],
10022                       bool replayed_pkt[], uint32_t nb_pkts, bool esn_en,
10023                       uint64_t winsz)
10024 {
10025         struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX];
10026         struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX];
10027         struct ipsec_test_flags flags;
10028         uint32_t i = 0, ret = 0;
10029
10030         memset(&flags, 0, sizeof(flags));
10031         flags.antireplay = true;
10032
10033         for (i = 0; i < nb_pkts; i++) {
10034                 memcpy(&td_outb[i], test_data, sizeof(td_outb[i]));
10035                 td_outb[i].ipsec_xform.options.iv_gen_disable = 1;
10036                 td_outb[i].ipsec_xform.replay_win_sz = winsz;
10037                 td_outb[i].ipsec_xform.options.esn = esn_en;
10038         }
10039
10040         for (i = 0; i < nb_pkts; i++)
10041                 td_outb[i].ipsec_xform.esn.value = esn[i];
10042
10043         ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true,
10044                                        &flags);
10045         if (ret != TEST_SUCCESS)
10046                 return ret;
10047
10048         test_ipsec_td_update(td_inb, td_outb, nb_pkts, &flags);
10049
10050         for (i = 0; i < nb_pkts; i++) {
10051                 td_inb[i].ipsec_xform.options.esn = esn_en;
10052                 /* Set antireplay flag for packets to be dropped */
10053                 td_inb[i].ar_packet = replayed_pkt[i];
10054         }
10055
10056         ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true,
10057                                        &flags);
10058
10059         return ret;
10060 }
10061
10062 static int
10063 test_ipsec_proto_pkt_antireplay(const void *test_data, uint64_t winsz)
10064 {
10065
10066         uint32_t nb_pkts = 5;
10067         bool replayed_pkt[5];
10068         uint64_t esn[5];
10069
10070         /* 1. Advance the TOP of the window to WS * 2 */
10071         esn[0] = winsz * 2;
10072         /* 2. Test sequence number within the new window(WS + 1) */
10073         esn[1] = winsz + 1;
10074         /* 3. Test sequence number less than the window BOTTOM */
10075         esn[2] = winsz;
10076         /* 4. Test sequence number in the middle of the window */
10077         esn[3] = winsz + (winsz / 2);
10078         /* 5. Test replay of the packet in the middle of the window */
10079         esn[4] = winsz + (winsz / 2);
10080
10081         replayed_pkt[0] = false;
10082         replayed_pkt[1] = false;
10083         replayed_pkt[2] = true;
10084         replayed_pkt[3] = false;
10085         replayed_pkt[4] = true;
10086
10087         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10088                                      false, winsz);
10089 }
10090
10091 static int
10092 test_ipsec_proto_pkt_antireplay1024(const void *test_data)
10093 {
10094         return test_ipsec_proto_pkt_antireplay(test_data, 1024);
10095 }
10096
10097 static int
10098 test_ipsec_proto_pkt_antireplay2048(const void *test_data)
10099 {
10100         return test_ipsec_proto_pkt_antireplay(test_data, 2048);
10101 }
10102
10103 static int
10104 test_ipsec_proto_pkt_antireplay4096(const void *test_data)
10105 {
10106         return test_ipsec_proto_pkt_antireplay(test_data, 4096);
10107 }
10108
10109 static int
10110 test_ipsec_proto_pkt_esn_antireplay(const void *test_data, uint64_t winsz)
10111 {
10112
10113         uint32_t nb_pkts = 7;
10114         bool replayed_pkt[7];
10115         uint64_t esn[7];
10116
10117         /* Set the initial sequence number */
10118         esn[0] = (uint64_t)(0xFFFFFFFF - winsz);
10119         /* 1. Advance the TOP of the window to (1<<32 + WS/2) */
10120         esn[1] = (uint64_t)((1ULL << 32) + (winsz / 2));
10121         /* 2. Test sequence number within new window (1<<32 + WS/2 + 1) */
10122         esn[2] = (uint64_t)((1ULL << 32) - (winsz / 2) + 1);
10123         /* 3. Test with sequence number within window (1<<32 - 1) */
10124         esn[3] = (uint64_t)((1ULL << 32) - 1);
10125         /* 4. Test with sequence number within window (1<<32 - 1) */
10126         esn[4] = (uint64_t)(1ULL << 32);
10127         /* 5. Test with duplicate sequence number within
10128          * new window (1<<32 - 1)
10129          */
10130         esn[5] = (uint64_t)((1ULL << 32) - 1);
10131         /* 6. Test with duplicate sequence number within new window (1<<32) */
10132         esn[6] = (uint64_t)(1ULL << 32);
10133
10134         replayed_pkt[0] = false;
10135         replayed_pkt[1] = false;
10136         replayed_pkt[2] = false;
10137         replayed_pkt[3] = false;
10138         replayed_pkt[4] = false;
10139         replayed_pkt[5] = true;
10140         replayed_pkt[6] = true;
10141
10142         return test_ipsec_pkt_replay(test_data, esn, replayed_pkt, nb_pkts,
10143                                      true, winsz);
10144 }
10145
10146 static int
10147 test_ipsec_proto_pkt_esn_antireplay1024(const void *test_data)
10148 {
10149         return test_ipsec_proto_pkt_esn_antireplay(test_data, 1024);
10150 }
10151
10152 static int
10153 test_ipsec_proto_pkt_esn_antireplay2048(const void *test_data)
10154 {
10155         return test_ipsec_proto_pkt_esn_antireplay(test_data, 2048);
10156 }
10157
10158 static int
10159 test_ipsec_proto_pkt_esn_antireplay4096(const void *test_data)
10160 {
10161         return test_ipsec_proto_pkt_esn_antireplay(test_data, 4096);
10162 }
10163
10164 static int
10165 test_PDCP_PROTO_all(void)
10166 {
10167         struct crypto_testsuite_params *ts_params = &testsuite_params;
10168         struct crypto_unittest_params *ut_params = &unittest_params;
10169         struct rte_cryptodev_info dev_info;
10170         int status;
10171
10172         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10173         uint64_t feat_flags = dev_info.feature_flags;
10174
10175         if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
10176                 return TEST_SKIPPED;
10177
10178         /* Set action type */
10179         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10180                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10181                 gbl_action_type;
10182
10183         if (security_proto_supported(ut_params->type,
10184                         RTE_SECURITY_PROTOCOL_PDCP) < 0)
10185                 return TEST_SKIPPED;
10186
10187         status = test_PDCP_PROTO_cplane_encap_all();
10188         status += test_PDCP_PROTO_cplane_decap_all();
10189         status += test_PDCP_PROTO_uplane_encap_all();
10190         status += test_PDCP_PROTO_uplane_decap_all();
10191         status += test_PDCP_PROTO_SGL_in_place_32B();
10192         status += test_PDCP_PROTO_SGL_oop_32B_128B();
10193         status += test_PDCP_PROTO_SGL_oop_32B_40B();
10194         status += test_PDCP_PROTO_SGL_oop_128B_32B();
10195         status += test_PDCP_SDAP_PROTO_encap_all();
10196         status += test_PDCP_SDAP_PROTO_decap_all();
10197         status += test_PDCP_PROTO_short_mac();
10198
10199         if (status)
10200                 return TEST_FAILED;
10201         else
10202                 return TEST_SUCCESS;
10203 }
10204
10205 static int
10206 test_ipsec_proto_ipv4_ttl_decrement(const void *data __rte_unused)
10207 {
10208         struct ipsec_test_flags flags = {
10209                 .dec_ttl_or_hop_limit = true
10210         };
10211
10212         return test_ipsec_proto_all(&flags);
10213 }
10214
10215 static int
10216 test_ipsec_proto_ipv6_hop_limit_decrement(const void *data __rte_unused)
10217 {
10218         struct ipsec_test_flags flags = {
10219                 .ipv6 = true,
10220                 .dec_ttl_or_hop_limit = true
10221         };
10222
10223         return test_ipsec_proto_all(&flags);
10224 }
10225
10226 static int
10227 test_docsis_proto_uplink(const void *data)
10228 {
10229         const struct docsis_test_data *d_td = data;
10230         struct crypto_testsuite_params *ts_params = &testsuite_params;
10231         struct crypto_unittest_params *ut_params = &unittest_params;
10232         uint8_t *plaintext = NULL;
10233         uint8_t *ciphertext = NULL;
10234         uint8_t *iv_ptr;
10235         int32_t cipher_len, crc_len;
10236         uint32_t crc_data_len;
10237         int ret = TEST_SUCCESS;
10238
10239         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10240                                         rte_cryptodev_get_sec_ctx(
10241                                                 ts_params->valid_devs[0]);
10242
10243         /* Verify the capabilities */
10244         struct rte_security_capability_idx sec_cap_idx;
10245         const struct rte_security_capability *sec_cap;
10246         const struct rte_cryptodev_capabilities *crypto_cap;
10247         const struct rte_cryptodev_symmetric_capability *sym_cap;
10248         int j = 0;
10249
10250         /* Set action type */
10251         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10252                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10253                 gbl_action_type;
10254
10255         if (security_proto_supported(ut_params->type,
10256                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10257                 return TEST_SKIPPED;
10258
10259         sec_cap_idx.action = ut_params->type;
10260         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10261         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK;
10262
10263         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10264         if (sec_cap == NULL)
10265                 return TEST_SKIPPED;
10266
10267         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10268                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10269                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10270                                 crypto_cap->sym.xform_type ==
10271                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10272                                 crypto_cap->sym.cipher.algo ==
10273                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10274                         sym_cap = &crypto_cap->sym;
10275                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10276                                                 d_td->key.len,
10277                                                 d_td->iv.len) == 0)
10278                                 break;
10279                 }
10280         }
10281
10282         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10283                 return TEST_SKIPPED;
10284
10285         /* Setup source mbuf payload */
10286         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10287         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10288                         rte_pktmbuf_tailroom(ut_params->ibuf));
10289
10290         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10291                         d_td->ciphertext.len);
10292
10293         memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len);
10294
10295         /* Setup cipher session parameters */
10296         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10297         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10298         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
10299         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10300         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10301         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10302         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10303         ut_params->cipher_xform.next = NULL;
10304
10305         /* Setup DOCSIS session parameters */
10306         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_UPLINK;
10307
10308         struct rte_security_session_conf sess_conf = {
10309                 .action_type = ut_params->type,
10310                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10311                 .docsis = ut_params->docsis_xform,
10312                 .crypto_xform = &ut_params->cipher_xform,
10313         };
10314
10315         /* Create security session */
10316         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10317                                         ts_params->session_mpool,
10318                                         ts_params->session_priv_mpool);
10319
10320         if (!ut_params->sec_session) {
10321                 printf("Test function %s line %u: failed to allocate session\n",
10322                         __func__, __LINE__);
10323                 ret = TEST_FAILED;
10324                 goto on_err;
10325         }
10326
10327         /* Generate crypto op data structure */
10328         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10329                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10330         if (!ut_params->op) {
10331                 printf("Test function %s line %u: failed to allocate symmetric "
10332                         "crypto operation\n", __func__, __LINE__);
10333                 ret = TEST_FAILED;
10334                 goto on_err;
10335         }
10336
10337         /* Setup CRC operation parameters */
10338         crc_len = d_td->ciphertext.no_crc == false ?
10339                         (d_td->ciphertext.len -
10340                                 d_td->ciphertext.crc_offset -
10341                                 RTE_ETHER_CRC_LEN) :
10342                         0;
10343         crc_len = crc_len > 0 ? crc_len : 0;
10344         crc_data_len = crc_len == 0 ? 0 : RTE_ETHER_CRC_LEN;
10345         ut_params->op->sym->auth.data.length = crc_len;
10346         ut_params->op->sym->auth.data.offset = d_td->ciphertext.crc_offset;
10347
10348         /* Setup cipher operation parameters */
10349         cipher_len = d_td->ciphertext.no_cipher == false ?
10350                         (d_td->ciphertext.len -
10351                                 d_td->ciphertext.cipher_offset) :
10352                         0;
10353         cipher_len = cipher_len > 0 ? cipher_len : 0;
10354         ut_params->op->sym->cipher.data.length = cipher_len;
10355         ut_params->op->sym->cipher.data.offset = d_td->ciphertext.cipher_offset;
10356
10357         /* Setup cipher IV */
10358         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10359         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10360
10361         /* Attach session to operation */
10362         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10363
10364         /* Set crypto operation mbufs */
10365         ut_params->op->sym->m_src = ut_params->ibuf;
10366         ut_params->op->sym->m_dst = NULL;
10367
10368         /* Process crypto operation */
10369         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10370                         NULL) {
10371                 printf("Test function %s line %u: failed to process security "
10372                         "crypto op\n", __func__, __LINE__);
10373                 ret = TEST_FAILED;
10374                 goto on_err;
10375         }
10376
10377         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10378                 printf("Test function %s line %u: failed to process crypto op\n",
10379                         __func__, __LINE__);
10380                 ret = TEST_FAILED;
10381                 goto on_err;
10382         }
10383
10384         /* Validate plaintext */
10385         plaintext = ciphertext;
10386
10387         if (memcmp(plaintext, d_td->plaintext.data,
10388                         d_td->plaintext.len - crc_data_len)) {
10389                 printf("Test function %s line %u: plaintext not as expected\n",
10390                         __func__, __LINE__);
10391                 rte_hexdump(stdout, "expected", d_td->plaintext.data,
10392                                 d_td->plaintext.len);
10393                 rte_hexdump(stdout, "actual", plaintext, d_td->plaintext.len);
10394                 ret = TEST_FAILED;
10395                 goto on_err;
10396         }
10397
10398 on_err:
10399         rte_crypto_op_free(ut_params->op);
10400         ut_params->op = NULL;
10401
10402         if (ut_params->sec_session)
10403                 rte_security_session_destroy(ctx, ut_params->sec_session);
10404         ut_params->sec_session = NULL;
10405
10406         rte_pktmbuf_free(ut_params->ibuf);
10407         ut_params->ibuf = NULL;
10408
10409         return ret;
10410 }
10411
10412 static int
10413 test_docsis_proto_downlink(const void *data)
10414 {
10415         const struct docsis_test_data *d_td = data;
10416         struct crypto_testsuite_params *ts_params = &testsuite_params;
10417         struct crypto_unittest_params *ut_params = &unittest_params;
10418         uint8_t *plaintext = NULL;
10419         uint8_t *ciphertext = NULL;
10420         uint8_t *iv_ptr;
10421         int32_t cipher_len, crc_len;
10422         int ret = TEST_SUCCESS;
10423
10424         struct rte_security_ctx *ctx = (struct rte_security_ctx *)
10425                                         rte_cryptodev_get_sec_ctx(
10426                                                 ts_params->valid_devs[0]);
10427
10428         /* Verify the capabilities */
10429         struct rte_security_capability_idx sec_cap_idx;
10430         const struct rte_security_capability *sec_cap;
10431         const struct rte_cryptodev_capabilities *crypto_cap;
10432         const struct rte_cryptodev_symmetric_capability *sym_cap;
10433         int j = 0;
10434
10435         /* Set action type */
10436         ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
10437                 RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL :
10438                 gbl_action_type;
10439
10440         if (security_proto_supported(ut_params->type,
10441                         RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
10442                 return TEST_SKIPPED;
10443
10444         sec_cap_idx.action = ut_params->type;
10445         sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS;
10446         sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10447
10448         sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
10449         if (sec_cap == NULL)
10450                 return TEST_SKIPPED;
10451
10452         while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
10453                         RTE_CRYPTO_OP_TYPE_UNDEFINED) {
10454                 if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_SYMMETRIC &&
10455                                 crypto_cap->sym.xform_type ==
10456                                         RTE_CRYPTO_SYM_XFORM_CIPHER &&
10457                                 crypto_cap->sym.cipher.algo ==
10458                                         RTE_CRYPTO_CIPHER_AES_DOCSISBPI) {
10459                         sym_cap = &crypto_cap->sym;
10460                         if (rte_cryptodev_sym_capability_check_cipher(sym_cap,
10461                                                 d_td->key.len,
10462                                                 d_td->iv.len) == 0)
10463                                 break;
10464                 }
10465         }
10466
10467         if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
10468                 return TEST_SKIPPED;
10469
10470         /* Setup source mbuf payload */
10471         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10472         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10473                         rte_pktmbuf_tailroom(ut_params->ibuf));
10474
10475         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
10476                         d_td->plaintext.len);
10477
10478         memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len);
10479
10480         /* Setup cipher session parameters */
10481         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
10482         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI;
10483         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
10484         ut_params->cipher_xform.cipher.key.data = d_td->key.data;
10485         ut_params->cipher_xform.cipher.key.length = d_td->key.len;
10486         ut_params->cipher_xform.cipher.iv.length = d_td->iv.len;
10487         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
10488         ut_params->cipher_xform.next = NULL;
10489
10490         /* Setup DOCSIS session parameters */
10491         ut_params->docsis_xform.direction = RTE_SECURITY_DOCSIS_DOWNLINK;
10492
10493         struct rte_security_session_conf sess_conf = {
10494                 .action_type = ut_params->type,
10495                 .protocol = RTE_SECURITY_PROTOCOL_DOCSIS,
10496                 .docsis = ut_params->docsis_xform,
10497                 .crypto_xform = &ut_params->cipher_xform,
10498         };
10499
10500         /* Create security session */
10501         ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
10502                                         ts_params->session_mpool,
10503                                         ts_params->session_priv_mpool);
10504
10505         if (!ut_params->sec_session) {
10506                 printf("Test function %s line %u: failed to allocate session\n",
10507                         __func__, __LINE__);
10508                 ret = TEST_FAILED;
10509                 goto on_err;
10510         }
10511
10512         /* Generate crypto op data structure */
10513         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
10514                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
10515         if (!ut_params->op) {
10516                 printf("Test function %s line %u: failed to allocate symmetric "
10517                         "crypto operation\n", __func__, __LINE__);
10518                 ret = TEST_FAILED;
10519                 goto on_err;
10520         }
10521
10522         /* Setup CRC operation parameters */
10523         crc_len = d_td->plaintext.no_crc == false ?
10524                         (d_td->plaintext.len -
10525                                 d_td->plaintext.crc_offset -
10526                                 RTE_ETHER_CRC_LEN) :
10527                         0;
10528         crc_len = crc_len > 0 ? crc_len : 0;
10529         ut_params->op->sym->auth.data.length = crc_len;
10530         ut_params->op->sym->auth.data.offset = d_td->plaintext.crc_offset;
10531
10532         /* Setup cipher operation parameters */
10533         cipher_len = d_td->plaintext.no_cipher == false ?
10534                         (d_td->plaintext.len -
10535                                 d_td->plaintext.cipher_offset) :
10536                         0;
10537         cipher_len = cipher_len > 0 ? cipher_len : 0;
10538         ut_params->op->sym->cipher.data.length = cipher_len;
10539         ut_params->op->sym->cipher.data.offset = d_td->plaintext.cipher_offset;
10540
10541         /* Setup cipher IV */
10542         iv_ptr = (uint8_t *)ut_params->op + IV_OFFSET;
10543         rte_memcpy(iv_ptr, d_td->iv.data, d_td->iv.len);
10544
10545         /* Attach session to operation */
10546         rte_security_attach_session(ut_params->op, ut_params->sec_session);
10547
10548         /* Set crypto operation mbufs */
10549         ut_params->op->sym->m_src = ut_params->ibuf;
10550         ut_params->op->sym->m_dst = NULL;
10551
10552         /* Process crypto operation */
10553         if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) ==
10554                         NULL) {
10555                 printf("Test function %s line %u: failed to process crypto op\n",
10556                         __func__, __LINE__);
10557                 ret = TEST_FAILED;
10558                 goto on_err;
10559         }
10560
10561         if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) {
10562                 printf("Test function %s line %u: crypto op processing failed\n",
10563                         __func__, __LINE__);
10564                 ret = TEST_FAILED;
10565                 goto on_err;
10566         }
10567
10568         /* Validate ciphertext */
10569         ciphertext = plaintext;
10570
10571         if (memcmp(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len)) {
10572                 printf("Test function %s line %u: plaintext not as expected\n",
10573                         __func__, __LINE__);
10574                 rte_hexdump(stdout, "expected", d_td->ciphertext.data,
10575                                 d_td->ciphertext.len);
10576                 rte_hexdump(stdout, "actual", ciphertext, d_td->ciphertext.len);
10577                 ret = TEST_FAILED;
10578                 goto on_err;
10579         }
10580
10581 on_err:
10582         rte_crypto_op_free(ut_params->op);
10583         ut_params->op = NULL;
10584
10585         if (ut_params->sec_session)
10586                 rte_security_session_destroy(ctx, ut_params->sec_session);
10587         ut_params->sec_session = NULL;
10588
10589         rte_pktmbuf_free(ut_params->ibuf);
10590         ut_params->ibuf = NULL;
10591
10592         return ret;
10593 }
10594 #endif
10595
10596 static int
10597 test_AES_GCM_authenticated_encryption_test_case_1(void)
10598 {
10599         return test_authenticated_encryption(&gcm_test_case_1);
10600 }
10601
10602 static int
10603 test_AES_GCM_authenticated_encryption_test_case_2(void)
10604 {
10605         return test_authenticated_encryption(&gcm_test_case_2);
10606 }
10607
10608 static int
10609 test_AES_GCM_authenticated_encryption_test_case_3(void)
10610 {
10611         return test_authenticated_encryption(&gcm_test_case_3);
10612 }
10613
10614 static int
10615 test_AES_GCM_authenticated_encryption_test_case_4(void)
10616 {
10617         return test_authenticated_encryption(&gcm_test_case_4);
10618 }
10619
10620 static int
10621 test_AES_GCM_authenticated_encryption_test_case_5(void)
10622 {
10623         return test_authenticated_encryption(&gcm_test_case_5);
10624 }
10625
10626 static int
10627 test_AES_GCM_authenticated_encryption_test_case_6(void)
10628 {
10629         return test_authenticated_encryption(&gcm_test_case_6);
10630 }
10631
10632 static int
10633 test_AES_GCM_authenticated_encryption_test_case_7(void)
10634 {
10635         return test_authenticated_encryption(&gcm_test_case_7);
10636 }
10637
10638 static int
10639 test_AES_GCM_authenticated_encryption_test_case_8(void)
10640 {
10641         return test_authenticated_encryption(&gcm_test_case_8);
10642 }
10643
10644 static int
10645 test_AES_GCM_J0_authenticated_encryption_test_case_1(void)
10646 {
10647         return test_authenticated_encryption(&gcm_J0_test_case_1);
10648 }
10649
10650 static int
10651 test_AES_GCM_auth_encryption_test_case_192_1(void)
10652 {
10653         return test_authenticated_encryption(&gcm_test_case_192_1);
10654 }
10655
10656 static int
10657 test_AES_GCM_auth_encryption_test_case_192_2(void)
10658 {
10659         return test_authenticated_encryption(&gcm_test_case_192_2);
10660 }
10661
10662 static int
10663 test_AES_GCM_auth_encryption_test_case_192_3(void)
10664 {
10665         return test_authenticated_encryption(&gcm_test_case_192_3);
10666 }
10667
10668 static int
10669 test_AES_GCM_auth_encryption_test_case_192_4(void)
10670 {
10671         return test_authenticated_encryption(&gcm_test_case_192_4);
10672 }
10673
10674 static int
10675 test_AES_GCM_auth_encryption_test_case_192_5(void)
10676 {
10677         return test_authenticated_encryption(&gcm_test_case_192_5);
10678 }
10679
10680 static int
10681 test_AES_GCM_auth_encryption_test_case_192_6(void)
10682 {
10683         return test_authenticated_encryption(&gcm_test_case_192_6);
10684 }
10685
10686 static int
10687 test_AES_GCM_auth_encryption_test_case_192_7(void)
10688 {
10689         return test_authenticated_encryption(&gcm_test_case_192_7);
10690 }
10691
10692 static int
10693 test_AES_GCM_auth_encryption_test_case_256_1(void)
10694 {
10695         return test_authenticated_encryption(&gcm_test_case_256_1);
10696 }
10697
10698 static int
10699 test_AES_GCM_auth_encryption_test_case_256_2(void)
10700 {
10701         return test_authenticated_encryption(&gcm_test_case_256_2);
10702 }
10703
10704 static int
10705 test_AES_GCM_auth_encryption_test_case_256_3(void)
10706 {
10707         return test_authenticated_encryption(&gcm_test_case_256_3);
10708 }
10709
10710 static int
10711 test_AES_GCM_auth_encryption_test_case_256_4(void)
10712 {
10713         return test_authenticated_encryption(&gcm_test_case_256_4);
10714 }
10715
10716 static int
10717 test_AES_GCM_auth_encryption_test_case_256_5(void)
10718 {
10719         return test_authenticated_encryption(&gcm_test_case_256_5);
10720 }
10721
10722 static int
10723 test_AES_GCM_auth_encryption_test_case_256_6(void)
10724 {
10725         return test_authenticated_encryption(&gcm_test_case_256_6);
10726 }
10727
10728 static int
10729 test_AES_GCM_auth_encryption_test_case_256_7(void)
10730 {
10731         return test_authenticated_encryption(&gcm_test_case_256_7);
10732 }
10733
10734 static int
10735 test_AES_GCM_auth_encryption_test_case_aad_1(void)
10736 {
10737         return test_authenticated_encryption(&gcm_test_case_aad_1);
10738 }
10739
10740 static int
10741 test_AES_GCM_auth_encryption_test_case_aad_2(void)
10742 {
10743         return test_authenticated_encryption(&gcm_test_case_aad_2);
10744 }
10745
10746 static int
10747 test_AES_GCM_auth_encryption_fail_iv_corrupt(void)
10748 {
10749         struct aead_test_data tdata;
10750         int res;
10751
10752         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10753         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10754         tdata.iv.data[0] += 1;
10755         res = test_authenticated_encryption(&tdata);
10756         if (res == TEST_SKIPPED)
10757                 return res;
10758         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10759         return TEST_SUCCESS;
10760 }
10761
10762 static int
10763 test_AES_GCM_auth_encryption_fail_in_data_corrupt(void)
10764 {
10765         struct aead_test_data tdata;
10766         int res;
10767
10768         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10769         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10770         tdata.plaintext.data[0] += 1;
10771         res = test_authenticated_encryption(&tdata);
10772         if (res == TEST_SKIPPED)
10773                 return res;
10774         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10775         return TEST_SUCCESS;
10776 }
10777
10778 static int
10779 test_AES_GCM_auth_encryption_fail_out_data_corrupt(void)
10780 {
10781         struct aead_test_data tdata;
10782         int res;
10783
10784         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10785         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10786         tdata.ciphertext.data[0] += 1;
10787         res = test_authenticated_encryption(&tdata);
10788         if (res == TEST_SKIPPED)
10789                 return res;
10790         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10791         return TEST_SUCCESS;
10792 }
10793
10794 static int
10795 test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void)
10796 {
10797         struct aead_test_data tdata;
10798         int res;
10799
10800         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10801         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10802         tdata.aad.len += 1;
10803         res = test_authenticated_encryption(&tdata);
10804         if (res == TEST_SKIPPED)
10805                 return res;
10806         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10807         return TEST_SUCCESS;
10808 }
10809
10810 static int
10811 test_AES_GCM_auth_encryption_fail_aad_corrupt(void)
10812 {
10813         struct aead_test_data tdata;
10814         uint8_t aad[gcm_test_case_7.aad.len];
10815         int res;
10816
10817         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10818         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10819         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
10820         aad[0] += 1;
10821         tdata.aad.data = aad;
10822         res = test_authenticated_encryption(&tdata);
10823         if (res == TEST_SKIPPED)
10824                 return res;
10825         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10826         return TEST_SUCCESS;
10827 }
10828
10829 static int
10830 test_AES_GCM_auth_encryption_fail_tag_corrupt(void)
10831 {
10832         struct aead_test_data tdata;
10833         int res;
10834
10835         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
10836         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
10837         tdata.auth_tag.data[0] += 1;
10838         res = test_authenticated_encryption(&tdata);
10839         if (res == TEST_SKIPPED)
10840                 return res;
10841         TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
10842         return TEST_SUCCESS;
10843 }
10844
10845 static int
10846 test_authenticated_decryption(const struct aead_test_data *tdata)
10847 {
10848         struct crypto_testsuite_params *ts_params = &testsuite_params;
10849         struct crypto_unittest_params *ut_params = &unittest_params;
10850
10851         int retval;
10852         uint8_t *plaintext;
10853         uint32_t i;
10854         struct rte_cryptodev_info dev_info;
10855
10856         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
10857         uint64_t feat_flags = dev_info.feature_flags;
10858
10859         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
10860                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
10861                 printf("Device doesn't support RAW data-path APIs.\n");
10862                 return TEST_SKIPPED;
10863         }
10864
10865         /* Verify the capabilities */
10866         struct rte_cryptodev_sym_capability_idx cap_idx;
10867         const struct rte_cryptodev_symmetric_capability *capability;
10868         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
10869         cap_idx.algo.aead = tdata->algo;
10870         capability = rte_cryptodev_sym_capability_get(
10871                         ts_params->valid_devs[0], &cap_idx);
10872         if (capability == NULL)
10873                 return TEST_SKIPPED;
10874         if (rte_cryptodev_sym_capability_check_aead(
10875                         capability, tdata->key.len, tdata->auth_tag.len,
10876                         tdata->aad.len, tdata->iv.len))
10877                 return TEST_SKIPPED;
10878
10879         /* Create AEAD session */
10880         retval = create_aead_session(ts_params->valid_devs[0],
10881                         tdata->algo,
10882                         RTE_CRYPTO_AEAD_OP_DECRYPT,
10883                         tdata->key.data, tdata->key.len,
10884                         tdata->aad.len, tdata->auth_tag.len,
10885                         tdata->iv.len);
10886         if (retval < 0)
10887                 return retval;
10888
10889         /* alloc mbuf and set payload */
10890         if (tdata->aad.len > MBUF_SIZE) {
10891                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
10892                 /* Populate full size of add data */
10893                 for (i = 32; i < MAX_AAD_LENGTH; i += 32)
10894                         memcpy(&tdata->aad.data[i], &tdata->aad.data[0], 32);
10895         } else
10896                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
10897
10898         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
10899                         rte_pktmbuf_tailroom(ut_params->ibuf));
10900
10901         /* Create AEAD operation */
10902         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
10903         if (retval < 0)
10904                 return retval;
10905
10906         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
10907
10908         ut_params->op->sym->m_src = ut_params->ibuf;
10909
10910         /* Process crypto operation */
10911         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
10912                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
10913         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
10914                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
10915                                 ut_params->op, 0, 0, 0, 0);
10916         else
10917                 TEST_ASSERT_NOT_NULL(
10918                         process_crypto_request(ts_params->valid_devs[0],
10919                         ut_params->op), "failed to process sym crypto op");
10920
10921         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
10922                         "crypto op processing failed");
10923
10924         if (ut_params->op->sym->m_dst)
10925                 plaintext = rte_pktmbuf_mtod(ut_params->op->sym->m_dst,
10926                                 uint8_t *);
10927         else
10928                 plaintext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
10929                                 uint8_t *,
10930                                 ut_params->op->sym->cipher.data.offset);
10931
10932         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
10933
10934         /* Validate obuf */
10935         TEST_ASSERT_BUFFERS_ARE_EQUAL(
10936                         plaintext,
10937                         tdata->plaintext.data,
10938                         tdata->plaintext.len,
10939                         "Plaintext data not as expected");
10940
10941         TEST_ASSERT_EQUAL(ut_params->op->status,
10942                         RTE_CRYPTO_OP_STATUS_SUCCESS,
10943                         "Authentication failed");
10944
10945         return 0;
10946 }
10947
10948 static int
10949 test_AES_GCM_authenticated_decryption_test_case_1(void)
10950 {
10951         return test_authenticated_decryption(&gcm_test_case_1);
10952 }
10953
10954 static int
10955 test_AES_GCM_authenticated_decryption_test_case_2(void)
10956 {
10957         return test_authenticated_decryption(&gcm_test_case_2);
10958 }
10959
10960 static int
10961 test_AES_GCM_authenticated_decryption_test_case_3(void)
10962 {
10963         return test_authenticated_decryption(&gcm_test_case_3);
10964 }
10965
10966 static int
10967 test_AES_GCM_authenticated_decryption_test_case_4(void)
10968 {
10969         return test_authenticated_decryption(&gcm_test_case_4);
10970 }
10971
10972 static int
10973 test_AES_GCM_authenticated_decryption_test_case_5(void)
10974 {
10975         return test_authenticated_decryption(&gcm_test_case_5);
10976 }
10977
10978 static int
10979 test_AES_GCM_authenticated_decryption_test_case_6(void)
10980 {
10981         return test_authenticated_decryption(&gcm_test_case_6);
10982 }
10983
10984 static int
10985 test_AES_GCM_authenticated_decryption_test_case_7(void)
10986 {
10987         return test_authenticated_decryption(&gcm_test_case_7);
10988 }
10989
10990 static int
10991 test_AES_GCM_authenticated_decryption_test_case_8(void)
10992 {
10993         return test_authenticated_decryption(&gcm_test_case_8);
10994 }
10995
10996 static int
10997 test_AES_GCM_J0_authenticated_decryption_test_case_1(void)
10998 {
10999         return test_authenticated_decryption(&gcm_J0_test_case_1);
11000 }
11001
11002 static int
11003 test_AES_GCM_auth_decryption_test_case_192_1(void)
11004 {
11005         return test_authenticated_decryption(&gcm_test_case_192_1);
11006 }
11007
11008 static int
11009 test_AES_GCM_auth_decryption_test_case_192_2(void)
11010 {
11011         return test_authenticated_decryption(&gcm_test_case_192_2);
11012 }
11013
11014 static int
11015 test_AES_GCM_auth_decryption_test_case_192_3(void)
11016 {
11017         return test_authenticated_decryption(&gcm_test_case_192_3);
11018 }
11019
11020 static int
11021 test_AES_GCM_auth_decryption_test_case_192_4(void)
11022 {
11023         return test_authenticated_decryption(&gcm_test_case_192_4);
11024 }
11025
11026 static int
11027 test_AES_GCM_auth_decryption_test_case_192_5(void)
11028 {
11029         return test_authenticated_decryption(&gcm_test_case_192_5);
11030 }
11031
11032 static int
11033 test_AES_GCM_auth_decryption_test_case_192_6(void)
11034 {
11035         return test_authenticated_decryption(&gcm_test_case_192_6);
11036 }
11037
11038 static int
11039 test_AES_GCM_auth_decryption_test_case_192_7(void)
11040 {
11041         return test_authenticated_decryption(&gcm_test_case_192_7);
11042 }
11043
11044 static int
11045 test_AES_GCM_auth_decryption_test_case_256_1(void)
11046 {
11047         return test_authenticated_decryption(&gcm_test_case_256_1);
11048 }
11049
11050 static int
11051 test_AES_GCM_auth_decryption_test_case_256_2(void)
11052 {
11053         return test_authenticated_decryption(&gcm_test_case_256_2);
11054 }
11055
11056 static int
11057 test_AES_GCM_auth_decryption_test_case_256_3(void)
11058 {
11059         return test_authenticated_decryption(&gcm_test_case_256_3);
11060 }
11061
11062 static int
11063 test_AES_GCM_auth_decryption_test_case_256_4(void)
11064 {
11065         return test_authenticated_decryption(&gcm_test_case_256_4);
11066 }
11067
11068 static int
11069 test_AES_GCM_auth_decryption_test_case_256_5(void)
11070 {
11071         return test_authenticated_decryption(&gcm_test_case_256_5);
11072 }
11073
11074 static int
11075 test_AES_GCM_auth_decryption_test_case_256_6(void)
11076 {
11077         return test_authenticated_decryption(&gcm_test_case_256_6);
11078 }
11079
11080 static int
11081 test_AES_GCM_auth_decryption_test_case_256_7(void)
11082 {
11083         return test_authenticated_decryption(&gcm_test_case_256_7);
11084 }
11085
11086 static int
11087 test_AES_GCM_auth_decryption_test_case_aad_1(void)
11088 {
11089         return test_authenticated_decryption(&gcm_test_case_aad_1);
11090 }
11091
11092 static int
11093 test_AES_GCM_auth_decryption_test_case_aad_2(void)
11094 {
11095         return test_authenticated_decryption(&gcm_test_case_aad_2);
11096 }
11097
11098 static int
11099 test_AES_GCM_auth_decryption_fail_iv_corrupt(void)
11100 {
11101         struct aead_test_data tdata;
11102         int res;
11103
11104         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11105         tdata.iv.data[0] += 1;
11106         res = test_authenticated_decryption(&tdata);
11107         if (res == TEST_SKIPPED)
11108                 return res;
11109         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11110         return TEST_SUCCESS;
11111 }
11112
11113 static int
11114 test_AES_GCM_auth_decryption_fail_in_data_corrupt(void)
11115 {
11116         struct aead_test_data tdata;
11117         int res;
11118
11119         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
11120         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11121         tdata.plaintext.data[0] += 1;
11122         res = test_authenticated_decryption(&tdata);
11123         if (res == TEST_SKIPPED)
11124                 return res;
11125         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11126         return TEST_SUCCESS;
11127 }
11128
11129 static int
11130 test_AES_GCM_auth_decryption_fail_out_data_corrupt(void)
11131 {
11132         struct aead_test_data tdata;
11133         int res;
11134
11135         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11136         tdata.ciphertext.data[0] += 1;
11137         res = test_authenticated_decryption(&tdata);
11138         if (res == TEST_SKIPPED)
11139                 return res;
11140         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11141         return TEST_SUCCESS;
11142 }
11143
11144 static int
11145 test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void)
11146 {
11147         struct aead_test_data tdata;
11148         int res;
11149
11150         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11151         tdata.aad.len += 1;
11152         res = test_authenticated_decryption(&tdata);
11153         if (res == TEST_SKIPPED)
11154                 return res;
11155         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11156         return TEST_SUCCESS;
11157 }
11158
11159 static int
11160 test_AES_GCM_auth_decryption_fail_aad_corrupt(void)
11161 {
11162         struct aead_test_data tdata;
11163         uint8_t aad[gcm_test_case_7.aad.len];
11164         int res;
11165
11166         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11167         memcpy(aad, gcm_test_case_7.aad.data, gcm_test_case_7.aad.len);
11168         aad[0] += 1;
11169         tdata.aad.data = aad;
11170         res = test_authenticated_decryption(&tdata);
11171         if (res == TEST_SKIPPED)
11172                 return res;
11173         TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
11174         return TEST_SUCCESS;
11175 }
11176
11177 static int
11178 test_AES_GCM_auth_decryption_fail_tag_corrupt(void)
11179 {
11180         struct aead_test_data tdata;
11181         int res;
11182
11183         memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
11184         tdata.auth_tag.data[0] += 1;
11185         res = test_authenticated_decryption(&tdata);
11186         if (res == TEST_SKIPPED)
11187                 return res;
11188         TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
11189         return TEST_SUCCESS;
11190 }
11191
11192 static int
11193 test_authenticated_encryption_oop(const struct aead_test_data *tdata)
11194 {
11195         struct crypto_testsuite_params *ts_params = &testsuite_params;
11196         struct crypto_unittest_params *ut_params = &unittest_params;
11197
11198         int retval;
11199         uint8_t *ciphertext, *auth_tag;
11200         uint16_t plaintext_pad_len;
11201         struct rte_cryptodev_info dev_info;
11202
11203         /* Verify the capabilities */
11204         struct rte_cryptodev_sym_capability_idx cap_idx;
11205         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11206         cap_idx.algo.aead = tdata->algo;
11207         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11208                         &cap_idx) == NULL)
11209                 return TEST_SKIPPED;
11210
11211         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11212         uint64_t feat_flags = dev_info.feature_flags;
11213
11214         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11215                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP)))
11216                 return TEST_SKIPPED;
11217
11218         /* not supported with CPU crypto */
11219         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11220                 return TEST_SKIPPED;
11221
11222         /* Create AEAD session */
11223         retval = create_aead_session(ts_params->valid_devs[0],
11224                         tdata->algo,
11225                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11226                         tdata->key.data, tdata->key.len,
11227                         tdata->aad.len, tdata->auth_tag.len,
11228                         tdata->iv.len);
11229         if (retval < 0)
11230                 return retval;
11231
11232         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11233         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11234
11235         /* clear mbuf payload */
11236         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11237                         rte_pktmbuf_tailroom(ut_params->ibuf));
11238         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11239                         rte_pktmbuf_tailroom(ut_params->obuf));
11240
11241         /* Create AEAD operation */
11242         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11243         if (retval < 0)
11244                 return retval;
11245
11246         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11247
11248         ut_params->op->sym->m_src = ut_params->ibuf;
11249         ut_params->op->sym->m_dst = ut_params->obuf;
11250
11251         /* Process crypto operation */
11252         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11253                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11254                         ut_params->op, 0, 0, 0, 0);
11255         else
11256                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11257                         ut_params->op), "failed to process sym crypto op");
11258
11259         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11260                         "crypto op processing failed");
11261
11262         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11263
11264         ciphertext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11265                         ut_params->op->sym->cipher.data.offset);
11266         auth_tag = ciphertext + plaintext_pad_len;
11267
11268         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11269         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11270
11271         /* Validate obuf */
11272         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11273                         ciphertext,
11274                         tdata->ciphertext.data,
11275                         tdata->ciphertext.len,
11276                         "Ciphertext data not as expected");
11277
11278         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11279                         auth_tag,
11280                         tdata->auth_tag.data,
11281                         tdata->auth_tag.len,
11282                         "Generated auth tag not as expected");
11283
11284         return 0;
11285
11286 }
11287
11288 static int
11289 test_AES_GCM_authenticated_encryption_oop_test_case_1(void)
11290 {
11291         return test_authenticated_encryption_oop(&gcm_test_case_5);
11292 }
11293
11294 static int
11295 test_authenticated_decryption_oop(const struct aead_test_data *tdata)
11296 {
11297         struct crypto_testsuite_params *ts_params = &testsuite_params;
11298         struct crypto_unittest_params *ut_params = &unittest_params;
11299
11300         int retval;
11301         uint8_t *plaintext;
11302         struct rte_cryptodev_info dev_info;
11303
11304         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11305         uint64_t feat_flags = dev_info.feature_flags;
11306
11307         /* Verify the capabilities */
11308         struct rte_cryptodev_sym_capability_idx cap_idx;
11309         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11310         cap_idx.algo.aead = tdata->algo;
11311         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11312                         &cap_idx) == NULL)
11313                 return TEST_SKIPPED;
11314
11315         /* not supported with CPU crypto and raw data-path APIs*/
11316         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
11317                         global_api_test_type == CRYPTODEV_RAW_API_TEST)
11318                 return TEST_SKIPPED;
11319
11320         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11321                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11322                 printf("Device does not support RAW data-path APIs.\n");
11323                 return TEST_SKIPPED;
11324         }
11325
11326         /* Create AEAD session */
11327         retval = create_aead_session(ts_params->valid_devs[0],
11328                         tdata->algo,
11329                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11330                         tdata->key.data, tdata->key.len,
11331                         tdata->aad.len, tdata->auth_tag.len,
11332                         tdata->iv.len);
11333         if (retval < 0)
11334                 return retval;
11335
11336         /* alloc mbuf and set payload */
11337         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11338         ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11339
11340         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11341                         rte_pktmbuf_tailroom(ut_params->ibuf));
11342         memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0,
11343                         rte_pktmbuf_tailroom(ut_params->obuf));
11344
11345         /* Create AEAD operation */
11346         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11347         if (retval < 0)
11348                 return retval;
11349
11350         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11351
11352         ut_params->op->sym->m_src = ut_params->ibuf;
11353         ut_params->op->sym->m_dst = ut_params->obuf;
11354
11355         /* Process crypto operation */
11356         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11357                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11358                                 ut_params->op, 0, 0, 0, 0);
11359         else
11360                 TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11361                         ut_params->op), "failed to process sym crypto op");
11362
11363         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11364                         "crypto op processing failed");
11365
11366         plaintext = rte_pktmbuf_mtod_offset(ut_params->obuf, uint8_t *,
11367                         ut_params->op->sym->cipher.data.offset);
11368
11369         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11370
11371         /* Validate obuf */
11372         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11373                         plaintext,
11374                         tdata->plaintext.data,
11375                         tdata->plaintext.len,
11376                         "Plaintext data not as expected");
11377
11378         TEST_ASSERT_EQUAL(ut_params->op->status,
11379                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11380                         "Authentication failed");
11381         return 0;
11382 }
11383
11384 static int
11385 test_AES_GCM_authenticated_decryption_oop_test_case_1(void)
11386 {
11387         return test_authenticated_decryption_oop(&gcm_test_case_5);
11388 }
11389
11390 static int
11391 test_authenticated_encryption_sessionless(
11392                 const struct aead_test_data *tdata)
11393 {
11394         struct crypto_testsuite_params *ts_params = &testsuite_params;
11395         struct crypto_unittest_params *ut_params = &unittest_params;
11396
11397         int retval;
11398         uint8_t *ciphertext, *auth_tag;
11399         uint16_t plaintext_pad_len;
11400         uint8_t key[tdata->key.len + 1];
11401         struct rte_cryptodev_info dev_info;
11402
11403         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11404         uint64_t feat_flags = dev_info.feature_flags;
11405
11406         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11407                 printf("Device doesn't support Sessionless ops.\n");
11408                 return TEST_SKIPPED;
11409         }
11410
11411         /* not supported with CPU crypto */
11412         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11413                 return TEST_SKIPPED;
11414
11415         /* Verify the capabilities */
11416         struct rte_cryptodev_sym_capability_idx cap_idx;
11417         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11418         cap_idx.algo.aead = tdata->algo;
11419         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11420                         &cap_idx) == NULL)
11421                 return TEST_SKIPPED;
11422
11423         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11424
11425         /* clear mbuf payload */
11426         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11427                         rte_pktmbuf_tailroom(ut_params->ibuf));
11428
11429         /* Create AEAD operation */
11430         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_ENCRYPT, tdata);
11431         if (retval < 0)
11432                 return retval;
11433
11434         /* Create GCM xform */
11435         memcpy(key, tdata->key.data, tdata->key.len);
11436         retval = create_aead_xform(ut_params->op,
11437                         tdata->algo,
11438                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
11439                         key, tdata->key.len,
11440                         tdata->aad.len, tdata->auth_tag.len,
11441                         tdata->iv.len);
11442         if (retval < 0)
11443                 return retval;
11444
11445         ut_params->op->sym->m_src = ut_params->ibuf;
11446
11447         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11448                         RTE_CRYPTO_OP_SESSIONLESS,
11449                         "crypto op session type not sessionless");
11450
11451         /* Process crypto operation */
11452         TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0],
11453                         ut_params->op), "failed to process sym crypto op");
11454
11455         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11456
11457         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11458                         "crypto op status not success");
11459
11460         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
11461
11462         ciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11463                         ut_params->op->sym->cipher.data.offset);
11464         auth_tag = ciphertext + plaintext_pad_len;
11465
11466         debug_hexdump(stdout, "ciphertext:", ciphertext, tdata->ciphertext.len);
11467         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->auth_tag.len);
11468
11469         /* Validate obuf */
11470         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11471                         ciphertext,
11472                         tdata->ciphertext.data,
11473                         tdata->ciphertext.len,
11474                         "Ciphertext data not as expected");
11475
11476         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11477                         auth_tag,
11478                         tdata->auth_tag.data,
11479                         tdata->auth_tag.len,
11480                         "Generated auth tag not as expected");
11481
11482         return 0;
11483
11484 }
11485
11486 static int
11487 test_AES_GCM_authenticated_encryption_sessionless_test_case_1(void)
11488 {
11489         return test_authenticated_encryption_sessionless(
11490                         &gcm_test_case_5);
11491 }
11492
11493 static int
11494 test_authenticated_decryption_sessionless(
11495                 const struct aead_test_data *tdata)
11496 {
11497         struct crypto_testsuite_params *ts_params = &testsuite_params;
11498         struct crypto_unittest_params *ut_params = &unittest_params;
11499
11500         int retval;
11501         uint8_t *plaintext;
11502         uint8_t key[tdata->key.len + 1];
11503         struct rte_cryptodev_info dev_info;
11504
11505         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11506         uint64_t feat_flags = dev_info.feature_flags;
11507
11508         if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
11509                 printf("Device doesn't support Sessionless ops.\n");
11510                 return TEST_SKIPPED;
11511         }
11512
11513         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11514                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11515                 printf("Device doesn't support RAW data-path APIs.\n");
11516                 return TEST_SKIPPED;
11517         }
11518
11519         /* not supported with CPU crypto */
11520         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11521                 return TEST_SKIPPED;
11522
11523         /* Verify the capabilities */
11524         struct rte_cryptodev_sym_capability_idx cap_idx;
11525         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
11526         cap_idx.algo.aead = tdata->algo;
11527         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11528                         &cap_idx) == NULL)
11529                 return TEST_SKIPPED;
11530
11531         /* alloc mbuf and set payload */
11532         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11533
11534         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11535                         rte_pktmbuf_tailroom(ut_params->ibuf));
11536
11537         /* Create AEAD operation */
11538         retval = create_aead_operation(RTE_CRYPTO_AEAD_OP_DECRYPT, tdata);
11539         if (retval < 0)
11540                 return retval;
11541
11542         /* Create AEAD xform */
11543         memcpy(key, tdata->key.data, tdata->key.len);
11544         retval = create_aead_xform(ut_params->op,
11545                         tdata->algo,
11546                         RTE_CRYPTO_AEAD_OP_DECRYPT,
11547                         key, tdata->key.len,
11548                         tdata->aad.len, tdata->auth_tag.len,
11549                         tdata->iv.len);
11550         if (retval < 0)
11551                 return retval;
11552
11553         ut_params->op->sym->m_src = ut_params->ibuf;
11554
11555         TEST_ASSERT_EQUAL(ut_params->op->sess_type,
11556                         RTE_CRYPTO_OP_SESSIONLESS,
11557                         "crypto op session type not sessionless");
11558
11559         /* Process crypto operation */
11560         if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11561                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11562                                 ut_params->op, 0, 0, 0, 0);
11563         else
11564                 TEST_ASSERT_NOT_NULL(process_crypto_request(
11565                         ts_params->valid_devs[0], ut_params->op),
11566                                 "failed to process sym crypto op");
11567
11568         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
11569
11570         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11571                         "crypto op status not success");
11572
11573         plaintext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
11574                         ut_params->op->sym->cipher.data.offset);
11575
11576         debug_hexdump(stdout, "plaintext:", plaintext, tdata->ciphertext.len);
11577
11578         /* Validate obuf */
11579         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11580                         plaintext,
11581                         tdata->plaintext.data,
11582                         tdata->plaintext.len,
11583                         "Plaintext data not as expected");
11584
11585         TEST_ASSERT_EQUAL(ut_params->op->status,
11586                         RTE_CRYPTO_OP_STATUS_SUCCESS,
11587                         "Authentication failed");
11588         return 0;
11589 }
11590
11591 static int
11592 test_AES_GCM_authenticated_decryption_sessionless_test_case_1(void)
11593 {
11594         return test_authenticated_decryption_sessionless(
11595                         &gcm_test_case_5);
11596 }
11597
11598 static int
11599 test_AES_CCM_authenticated_encryption_test_case_128_1(void)
11600 {
11601         return test_authenticated_encryption(&ccm_test_case_128_1);
11602 }
11603
11604 static int
11605 test_AES_CCM_authenticated_encryption_test_case_128_2(void)
11606 {
11607         return test_authenticated_encryption(&ccm_test_case_128_2);
11608 }
11609
11610 static int
11611 test_AES_CCM_authenticated_encryption_test_case_128_3(void)
11612 {
11613         return test_authenticated_encryption(&ccm_test_case_128_3);
11614 }
11615
11616 static int
11617 test_AES_CCM_authenticated_decryption_test_case_128_1(void)
11618 {
11619         return test_authenticated_decryption(&ccm_test_case_128_1);
11620 }
11621
11622 static int
11623 test_AES_CCM_authenticated_decryption_test_case_128_2(void)
11624 {
11625         return test_authenticated_decryption(&ccm_test_case_128_2);
11626 }
11627
11628 static int
11629 test_AES_CCM_authenticated_decryption_test_case_128_3(void)
11630 {
11631         return test_authenticated_decryption(&ccm_test_case_128_3);
11632 }
11633
11634 static int
11635 test_AES_CCM_authenticated_encryption_test_case_192_1(void)
11636 {
11637         return test_authenticated_encryption(&ccm_test_case_192_1);
11638 }
11639
11640 static int
11641 test_AES_CCM_authenticated_encryption_test_case_192_2(void)
11642 {
11643         return test_authenticated_encryption(&ccm_test_case_192_2);
11644 }
11645
11646 static int
11647 test_AES_CCM_authenticated_encryption_test_case_192_3(void)
11648 {
11649         return test_authenticated_encryption(&ccm_test_case_192_3);
11650 }
11651
11652 static int
11653 test_AES_CCM_authenticated_decryption_test_case_192_1(void)
11654 {
11655         return test_authenticated_decryption(&ccm_test_case_192_1);
11656 }
11657
11658 static int
11659 test_AES_CCM_authenticated_decryption_test_case_192_2(void)
11660 {
11661         return test_authenticated_decryption(&ccm_test_case_192_2);
11662 }
11663
11664 static int
11665 test_AES_CCM_authenticated_decryption_test_case_192_3(void)
11666 {
11667         return test_authenticated_decryption(&ccm_test_case_192_3);
11668 }
11669
11670 static int
11671 test_AES_CCM_authenticated_encryption_test_case_256_1(void)
11672 {
11673         return test_authenticated_encryption(&ccm_test_case_256_1);
11674 }
11675
11676 static int
11677 test_AES_CCM_authenticated_encryption_test_case_256_2(void)
11678 {
11679         return test_authenticated_encryption(&ccm_test_case_256_2);
11680 }
11681
11682 static int
11683 test_AES_CCM_authenticated_encryption_test_case_256_3(void)
11684 {
11685         return test_authenticated_encryption(&ccm_test_case_256_3);
11686 }
11687
11688 static int
11689 test_AES_CCM_authenticated_decryption_test_case_256_1(void)
11690 {
11691         return test_authenticated_decryption(&ccm_test_case_256_1);
11692 }
11693
11694 static int
11695 test_AES_CCM_authenticated_decryption_test_case_256_2(void)
11696 {
11697         return test_authenticated_decryption(&ccm_test_case_256_2);
11698 }
11699
11700 static int
11701 test_AES_CCM_authenticated_decryption_test_case_256_3(void)
11702 {
11703         return test_authenticated_decryption(&ccm_test_case_256_3);
11704 }
11705
11706 static int
11707 test_stats(void)
11708 {
11709         struct crypto_testsuite_params *ts_params = &testsuite_params;
11710         struct rte_cryptodev_stats stats;
11711
11712         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11713                 return TEST_SKIPPED;
11714
11715         /* Verify the capabilities */
11716         struct rte_cryptodev_sym_capability_idx cap_idx;
11717         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11718         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
11719         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11720                         &cap_idx) == NULL)
11721                 return TEST_SKIPPED;
11722         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
11723         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
11724         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11725                         &cap_idx) == NULL)
11726                 return TEST_SKIPPED;
11727
11728         if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
11729                         == -ENOTSUP)
11730                 return TEST_SKIPPED;
11731
11732         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11733         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
11734                         &stats) == -ENODEV),
11735                 "rte_cryptodev_stats_get invalid dev failed");
11736         TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0], 0) != 0),
11737                 "rte_cryptodev_stats_get invalid Param failed");
11738
11739         /* Test expected values */
11740         test_AES_CBC_HMAC_SHA1_encrypt_digest();
11741         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11742                         &stats),
11743                 "rte_cryptodev_stats_get failed");
11744         TEST_ASSERT((stats.enqueued_count == 1),
11745                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11746         TEST_ASSERT((stats.dequeued_count == 1),
11747                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11748         TEST_ASSERT((stats.enqueue_err_count == 0),
11749                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11750         TEST_ASSERT((stats.dequeue_err_count == 0),
11751                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11752
11753         /* invalid device but should ignore and not reset device stats*/
11754         rte_cryptodev_stats_reset(ts_params->valid_devs[0] + 300);
11755         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11756                         &stats),
11757                 "rte_cryptodev_stats_get failed");
11758         TEST_ASSERT((stats.enqueued_count == 1),
11759                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11760
11761         /* check that a valid reset clears stats */
11762         rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
11763         TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0],
11764                         &stats),
11765                                           "rte_cryptodev_stats_get failed");
11766         TEST_ASSERT((stats.enqueued_count == 0),
11767                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11768         TEST_ASSERT((stats.dequeued_count == 0),
11769                 "rte_cryptodev_stats_get returned unexpected enqueued stat");
11770
11771         return TEST_SUCCESS;
11772 }
11773
11774 static int MD5_HMAC_create_session(struct crypto_testsuite_params *ts_params,
11775                                    struct crypto_unittest_params *ut_params,
11776                                    enum rte_crypto_auth_operation op,
11777                                    const struct HMAC_MD5_vector *test_case)
11778 {
11779         uint8_t key[64];
11780         int status;
11781
11782         memcpy(key, test_case->key.data, test_case->key.len);
11783
11784         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11785         ut_params->auth_xform.next = NULL;
11786         ut_params->auth_xform.auth.op = op;
11787
11788         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_MD5_HMAC;
11789
11790         ut_params->auth_xform.auth.digest_length = MD5_DIGEST_LEN;
11791         ut_params->auth_xform.auth.key.length = test_case->key.len;
11792         ut_params->auth_xform.auth.key.data = key;
11793
11794         ut_params->sess = rte_cryptodev_sym_session_create(
11795                         ts_params->session_mpool);
11796         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
11797         if (ut_params->sess == NULL)
11798                 return TEST_FAILED;
11799
11800         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
11801                         ut_params->sess, &ut_params->auth_xform,
11802                         ts_params->session_priv_mpool);
11803         if (status == -ENOTSUP)
11804                 return TEST_SKIPPED;
11805
11806         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
11807
11808         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
11809                         rte_pktmbuf_tailroom(ut_params->ibuf));
11810
11811         return 0;
11812 }
11813
11814 static int MD5_HMAC_create_op(struct crypto_unittest_params *ut_params,
11815                               const struct HMAC_MD5_vector *test_case,
11816                               uint8_t **plaintext)
11817 {
11818         uint16_t plaintext_pad_len;
11819
11820         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
11821
11822         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11823                                 16);
11824
11825         *plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
11826                         plaintext_pad_len);
11827         memcpy(*plaintext, test_case->plaintext.data,
11828                         test_case->plaintext.len);
11829
11830         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
11831                         ut_params->ibuf, MD5_DIGEST_LEN);
11832         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
11833                         "no room to append digest");
11834         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
11835                         ut_params->ibuf, plaintext_pad_len);
11836
11837         if (ut_params->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) {
11838                 rte_memcpy(sym_op->auth.digest.data, test_case->auth_tag.data,
11839                            test_case->auth_tag.len);
11840         }
11841
11842         sym_op->auth.data.offset = 0;
11843         sym_op->auth.data.length = test_case->plaintext.len;
11844
11845         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
11846         ut_params->op->sym->m_src = ut_params->ibuf;
11847
11848         return 0;
11849 }
11850
11851 static int
11852 test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case)
11853 {
11854         uint16_t plaintext_pad_len;
11855         uint8_t *plaintext, *auth_tag;
11856
11857         struct crypto_testsuite_params *ts_params = &testsuite_params;
11858         struct crypto_unittest_params *ut_params = &unittest_params;
11859         struct rte_cryptodev_info dev_info;
11860
11861         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11862         uint64_t feat_flags = dev_info.feature_flags;
11863
11864         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11865                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11866                 printf("Device doesn't support RAW data-path APIs.\n");
11867                 return TEST_SKIPPED;
11868         }
11869
11870         /* Verify the capabilities */
11871         struct rte_cryptodev_sym_capability_idx cap_idx;
11872         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11873         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11874         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11875                         &cap_idx) == NULL)
11876                 return TEST_SKIPPED;
11877
11878         if (MD5_HMAC_create_session(ts_params, ut_params,
11879                         RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
11880                 return TEST_FAILED;
11881
11882         /* Generate Crypto op data structure */
11883         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11884                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11885         TEST_ASSERT_NOT_NULL(ut_params->op,
11886                         "Failed to allocate symmetric crypto operation struct");
11887
11888         plaintext_pad_len = RTE_ALIGN_CEIL(test_case->plaintext.len,
11889                                 16);
11890
11891         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11892                 return TEST_FAILED;
11893
11894         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11895                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11896                         ut_params->op);
11897         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11898                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11899                                 ut_params->op, 0, 1, 0, 0);
11900         else
11901                 TEST_ASSERT_NOT_NULL(
11902                         process_crypto_request(ts_params->valid_devs[0],
11903                                 ut_params->op),
11904                                 "failed to process sym crypto op");
11905
11906         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11907                         "crypto op processing failed");
11908
11909         if (ut_params->op->sym->m_dst) {
11910                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
11911                                 uint8_t *, plaintext_pad_len);
11912         } else {
11913                 auth_tag = plaintext + plaintext_pad_len;
11914         }
11915
11916         TEST_ASSERT_BUFFERS_ARE_EQUAL(
11917                         auth_tag,
11918                         test_case->auth_tag.data,
11919                         test_case->auth_tag.len,
11920                         "HMAC_MD5 generated tag not as expected");
11921
11922         return TEST_SUCCESS;
11923 }
11924
11925 static int
11926 test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case)
11927 {
11928         uint8_t *plaintext;
11929
11930         struct crypto_testsuite_params *ts_params = &testsuite_params;
11931         struct crypto_unittest_params *ut_params = &unittest_params;
11932         struct rte_cryptodev_info dev_info;
11933
11934         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
11935         uint64_t feat_flags = dev_info.feature_flags;
11936
11937         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
11938                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
11939                 printf("Device doesn't support RAW data-path APIs.\n");
11940                 return TEST_SKIPPED;
11941         }
11942
11943         /* Verify the capabilities */
11944         struct rte_cryptodev_sym_capability_idx cap_idx;
11945         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
11946         cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
11947         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
11948                         &cap_idx) == NULL)
11949                 return TEST_SKIPPED;
11950
11951         if (MD5_HMAC_create_session(ts_params, ut_params,
11952                         RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
11953                 return TEST_FAILED;
11954         }
11955
11956         /* Generate Crypto op data structure */
11957         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
11958                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
11959         TEST_ASSERT_NOT_NULL(ut_params->op,
11960                         "Failed to allocate symmetric crypto operation struct");
11961
11962         if (MD5_HMAC_create_op(ut_params, test_case, &plaintext))
11963                 return TEST_FAILED;
11964
11965         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
11966                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
11967                         ut_params->op);
11968         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
11969                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
11970                                 ut_params->op, 0, 1, 0, 0);
11971         else
11972                 TEST_ASSERT_NOT_NULL(
11973                         process_crypto_request(ts_params->valid_devs[0],
11974                                 ut_params->op),
11975                                 "failed to process sym crypto op");
11976
11977         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
11978                         "HMAC_MD5 crypto op processing failed");
11979
11980         return TEST_SUCCESS;
11981 }
11982
11983 static int
11984 test_MD5_HMAC_generate_case_1(void)
11985 {
11986         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_1);
11987 }
11988
11989 static int
11990 test_MD5_HMAC_verify_case_1(void)
11991 {
11992         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_1);
11993 }
11994
11995 static int
11996 test_MD5_HMAC_generate_case_2(void)
11997 {
11998         return test_MD5_HMAC_generate(&HMAC_MD5_test_case_2);
11999 }
12000
12001 static int
12002 test_MD5_HMAC_verify_case_2(void)
12003 {
12004         return test_MD5_HMAC_verify(&HMAC_MD5_test_case_2);
12005 }
12006
12007 static int
12008 test_multi_session(void)
12009 {
12010         struct crypto_testsuite_params *ts_params = &testsuite_params;
12011         struct crypto_unittest_params *ut_params = &unittest_params;
12012
12013         struct rte_cryptodev_info dev_info;
12014         struct rte_cryptodev_sym_session **sessions;
12015
12016         uint16_t i;
12017         int status;
12018
12019         /* Verify the capabilities */
12020         struct rte_cryptodev_sym_capability_idx cap_idx;
12021         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12022         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12023         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12024                         &cap_idx) == NULL)
12025                 return TEST_SKIPPED;
12026         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12027         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12028         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12029                         &cap_idx) == NULL)
12030                 return TEST_SKIPPED;
12031
12032         test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
12033                         aes_cbc_key, hmac_sha512_key);
12034
12035
12036         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12037
12038         sessions = rte_malloc(NULL,
12039                         sizeof(struct rte_cryptodev_sym_session *) *
12040                         (MAX_NB_SESSIONS + 1), 0);
12041
12042         /* Create multiple crypto sessions*/
12043         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12044
12045                 sessions[i] = rte_cryptodev_sym_session_create(
12046                                 ts_params->session_mpool);
12047                 TEST_ASSERT_NOT_NULL(sessions[i],
12048                                 "Session creation failed at session number %u",
12049                                 i);
12050
12051                 status = rte_cryptodev_sym_session_init(
12052                                 ts_params->valid_devs[0],
12053                                 sessions[i], &ut_params->auth_xform,
12054                                 ts_params->session_priv_mpool);
12055                 if (status == -ENOTSUP)
12056                         return TEST_SKIPPED;
12057
12058                 /* Attempt to send a request on each session */
12059                 TEST_ASSERT_SUCCESS( test_AES_CBC_HMAC_SHA512_decrypt_perform(
12060                         sessions[i],
12061                         ut_params,
12062                         ts_params,
12063                         catch_22_quote_2_512_bytes_AES_CBC_ciphertext,
12064                         catch_22_quote_2_512_bytes_AES_CBC_HMAC_SHA512_digest,
12065                         aes_cbc_iv),
12066                         "Failed to perform decrypt on request number %u.", i);
12067                 /* free crypto operation structure */
12068                 if (ut_params->op)
12069                         rte_crypto_op_free(ut_params->op);
12070
12071                 /*
12072                  * free mbuf - both obuf and ibuf are usually the same,
12073                  * so check if they point at the same address is necessary,
12074                  * to avoid freeing the mbuf twice.
12075                  */
12076                 if (ut_params->obuf) {
12077                         rte_pktmbuf_free(ut_params->obuf);
12078                         if (ut_params->ibuf == ut_params->obuf)
12079                                 ut_params->ibuf = 0;
12080                         ut_params->obuf = 0;
12081                 }
12082                 if (ut_params->ibuf) {
12083                         rte_pktmbuf_free(ut_params->ibuf);
12084                         ut_params->ibuf = 0;
12085                 }
12086         }
12087
12088         sessions[i] = NULL;
12089         /* Next session create should fail */
12090         rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12091                         sessions[i], &ut_params->auth_xform,
12092                         ts_params->session_priv_mpool);
12093         TEST_ASSERT_NULL(sessions[i],
12094                         "Session creation succeeded unexpectedly!");
12095
12096         for (i = 0; i < MAX_NB_SESSIONS; i++) {
12097                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12098                                 sessions[i]);
12099                 rte_cryptodev_sym_session_free(sessions[i]);
12100         }
12101
12102         rte_free(sessions);
12103
12104         return TEST_SUCCESS;
12105 }
12106
12107 struct multi_session_params {
12108         struct crypto_unittest_params ut_params;
12109         uint8_t *cipher_key;
12110         uint8_t *hmac_key;
12111         const uint8_t *cipher;
12112         const uint8_t *digest;
12113         uint8_t *iv;
12114 };
12115
12116 #define MB_SESSION_NUMBER 3
12117
12118 static int
12119 test_multi_session_random_usage(void)
12120 {
12121         struct crypto_testsuite_params *ts_params = &testsuite_params;
12122         struct rte_cryptodev_info dev_info;
12123         struct rte_cryptodev_sym_session **sessions;
12124         uint32_t i, j;
12125         struct multi_session_params ut_paramz[] = {
12126
12127                 {
12128                         .cipher_key = ms_aes_cbc_key0,
12129                         .hmac_key = ms_hmac_key0,
12130                         .cipher = ms_aes_cbc_cipher0,
12131                         .digest = ms_hmac_digest0,
12132                         .iv = ms_aes_cbc_iv0
12133                 },
12134                 {
12135                         .cipher_key = ms_aes_cbc_key1,
12136                         .hmac_key = ms_hmac_key1,
12137                         .cipher = ms_aes_cbc_cipher1,
12138                         .digest = ms_hmac_digest1,
12139                         .iv = ms_aes_cbc_iv1
12140                 },
12141                 {
12142                         .cipher_key = ms_aes_cbc_key2,
12143                         .hmac_key = ms_hmac_key2,
12144                         .cipher = ms_aes_cbc_cipher2,
12145                         .digest = ms_hmac_digest2,
12146                         .iv = ms_aes_cbc_iv2
12147                 },
12148
12149         };
12150         int status;
12151
12152         /* Verify the capabilities */
12153         struct rte_cryptodev_sym_capability_idx cap_idx;
12154         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12155         cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
12156         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12157                         &cap_idx) == NULL)
12158                 return TEST_SKIPPED;
12159         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12160         cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
12161         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12162                         &cap_idx) == NULL)
12163                 return TEST_SKIPPED;
12164
12165         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12166
12167         sessions = rte_malloc(NULL,
12168                         (sizeof(struct rte_cryptodev_sym_session *)
12169                                         * MAX_NB_SESSIONS) + 1, 0);
12170
12171         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12172                 sessions[i] = rte_cryptodev_sym_session_create(
12173                                 ts_params->session_mpool);
12174                 TEST_ASSERT_NOT_NULL(sessions[i],
12175                                 "Session creation failed at session number %u",
12176                                 i);
12177
12178                 rte_memcpy(&ut_paramz[i].ut_params, &unittest_params,
12179                                 sizeof(struct crypto_unittest_params));
12180
12181                 test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(
12182                                 &ut_paramz[i].ut_params,
12183                                 ut_paramz[i].cipher_key, ut_paramz[i].hmac_key);
12184
12185                 /* Create multiple crypto sessions*/
12186                 status = rte_cryptodev_sym_session_init(
12187                                 ts_params->valid_devs[0],
12188                                 sessions[i],
12189                                 &ut_paramz[i].ut_params.auth_xform,
12190                                 ts_params->session_priv_mpool);
12191
12192                 if (status == -ENOTSUP)
12193                         return TEST_SKIPPED;
12194
12195                 TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12196         }
12197
12198         srand(time(NULL));
12199         for (i = 0; i < 40000; i++) {
12200
12201                 j = rand() % MB_SESSION_NUMBER;
12202
12203                 TEST_ASSERT_SUCCESS(
12204                         test_AES_CBC_HMAC_SHA512_decrypt_perform(
12205                                         sessions[j],
12206                                         &ut_paramz[j].ut_params,
12207                                         ts_params, ut_paramz[j].cipher,
12208                                         ut_paramz[j].digest,
12209                                         ut_paramz[j].iv),
12210                         "Failed to perform decrypt on request number %u.", i);
12211
12212                 if (ut_paramz[j].ut_params.op)
12213                         rte_crypto_op_free(ut_paramz[j].ut_params.op);
12214
12215                 /*
12216                  * free mbuf - both obuf and ibuf are usually the same,
12217                  * so check if they point at the same address is necessary,
12218                  * to avoid freeing the mbuf twice.
12219                  */
12220                 if (ut_paramz[j].ut_params.obuf) {
12221                         rte_pktmbuf_free(ut_paramz[j].ut_params.obuf);
12222                         if (ut_paramz[j].ut_params.ibuf
12223                                         == ut_paramz[j].ut_params.obuf)
12224                                 ut_paramz[j].ut_params.ibuf = 0;
12225                         ut_paramz[j].ut_params.obuf = 0;
12226                 }
12227                 if (ut_paramz[j].ut_params.ibuf) {
12228                         rte_pktmbuf_free(ut_paramz[j].ut_params.ibuf);
12229                         ut_paramz[j].ut_params.ibuf = 0;
12230                 }
12231         }
12232
12233         for (i = 0; i < MB_SESSION_NUMBER; i++) {
12234                 rte_cryptodev_sym_session_clear(ts_params->valid_devs[0],
12235                                 sessions[i]);
12236                 rte_cryptodev_sym_session_free(sessions[i]);
12237         }
12238
12239         rte_free(sessions);
12240
12241         return TEST_SUCCESS;
12242 }
12243
12244 uint8_t orig_data[] = {0xab, 0xab, 0xab, 0xab,
12245                         0xab, 0xab, 0xab, 0xab,
12246                         0xab, 0xab, 0xab, 0xab,
12247                         0xab, 0xab, 0xab, 0xab};
12248
12249 static int
12250 test_null_invalid_operation(void)
12251 {
12252         struct crypto_testsuite_params *ts_params = &testsuite_params;
12253         struct crypto_unittest_params *ut_params = &unittest_params;
12254         int ret;
12255
12256         /* This test is for NULL PMD only */
12257         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12258                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12259                 return TEST_SKIPPED;
12260
12261         /* Setup Cipher Parameters */
12262         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12263         ut_params->cipher_xform.next = NULL;
12264
12265         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
12266         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12267
12268         ut_params->sess = rte_cryptodev_sym_session_create(
12269                         ts_params->session_mpool);
12270
12271         /* Create Crypto session*/
12272         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12273                         ut_params->sess, &ut_params->cipher_xform,
12274                         ts_params->session_priv_mpool);
12275         TEST_ASSERT(ret < 0,
12276                         "Session creation succeeded unexpectedly");
12277
12278
12279         /* Setup HMAC Parameters */
12280         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12281         ut_params->auth_xform.next = NULL;
12282
12283         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
12284         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12285
12286         ut_params->sess = rte_cryptodev_sym_session_create(
12287                         ts_params->session_mpool);
12288
12289         /* Create Crypto session*/
12290         ret = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12291                         ut_params->sess, &ut_params->auth_xform,
12292                         ts_params->session_priv_mpool);
12293         TEST_ASSERT(ret < 0,
12294                         "Session creation succeeded unexpectedly");
12295
12296         return TEST_SUCCESS;
12297 }
12298
12299
12300 #define NULL_BURST_LENGTH (32)
12301
12302 static int
12303 test_null_burst_operation(void)
12304 {
12305         struct crypto_testsuite_params *ts_params = &testsuite_params;
12306         struct crypto_unittest_params *ut_params = &unittest_params;
12307         int status;
12308
12309         unsigned i, burst_len = NULL_BURST_LENGTH;
12310
12311         struct rte_crypto_op *burst[NULL_BURST_LENGTH] = { NULL };
12312         struct rte_crypto_op *burst_dequeued[NULL_BURST_LENGTH] = { NULL };
12313
12314         /* This test is for NULL PMD only */
12315         if (gbl_driver_id != rte_cryptodev_driver_id_get(
12316                         RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
12317                 return TEST_SKIPPED;
12318
12319         /* Setup Cipher Parameters */
12320         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
12321         ut_params->cipher_xform.next = &ut_params->auth_xform;
12322
12323         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_NULL;
12324         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
12325
12326         /* Setup HMAC Parameters */
12327         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12328         ut_params->auth_xform.next = NULL;
12329
12330         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL;
12331         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
12332
12333         ut_params->sess = rte_cryptodev_sym_session_create(
12334                         ts_params->session_mpool);
12335         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12336
12337         /* Create Crypto session*/
12338         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
12339                         ut_params->sess, &ut_params->cipher_xform,
12340                         ts_params->session_priv_mpool);
12341
12342         if (status == -ENOTSUP)
12343                 return TEST_SKIPPED;
12344
12345         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
12346
12347         TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
12348                         RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
12349                         burst_len, "failed to generate burst of crypto ops");
12350
12351         /* Generate an operation for each mbuf in burst */
12352         for (i = 0; i < burst_len; i++) {
12353                 struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12354
12355                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
12356
12357                 unsigned *data = (unsigned *)rte_pktmbuf_append(m,
12358                                 sizeof(unsigned));
12359                 *data = i;
12360
12361                 rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
12362
12363                 burst[i]->sym->m_src = m;
12364         }
12365
12366         /* Process crypto operation */
12367         TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
12368                         0, burst, burst_len),
12369                         burst_len,
12370                         "Error enqueuing burst");
12371
12372         TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
12373                         0, burst_dequeued, burst_len),
12374                         burst_len,
12375                         "Error dequeuing burst");
12376
12377
12378         for (i = 0; i < burst_len; i++) {
12379                 TEST_ASSERT_EQUAL(
12380                         *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
12381                         *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
12382                                         uint32_t *),
12383                         "data not as expected");
12384
12385                 rte_pktmbuf_free(burst[i]->sym->m_src);
12386                 rte_crypto_op_free(burst[i]);
12387         }
12388
12389         return TEST_SUCCESS;
12390 }
12391
12392 static uint16_t
12393 test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12394                   uint16_t nb_ops, void *user_param)
12395 {
12396         RTE_SET_USED(dev_id);
12397         RTE_SET_USED(qp_id);
12398         RTE_SET_USED(ops);
12399         RTE_SET_USED(user_param);
12400
12401         printf("crypto enqueue callback called\n");
12402         return nb_ops;
12403 }
12404
12405 static uint16_t
12406 test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
12407                   uint16_t nb_ops, void *user_param)
12408 {
12409         RTE_SET_USED(dev_id);
12410         RTE_SET_USED(qp_id);
12411         RTE_SET_USED(ops);
12412         RTE_SET_USED(user_param);
12413
12414         printf("crypto dequeue callback called\n");
12415         return nb_ops;
12416 }
12417
12418 /*
12419  * Thread using enqueue/dequeue callback with RCU.
12420  */
12421 static int
12422 test_enqdeq_callback_thread(void *arg)
12423 {
12424         RTE_SET_USED(arg);
12425         /* DP thread calls rte_cryptodev_enqueue_burst()/
12426          * rte_cryptodev_dequeue_burst() and invokes callback.
12427          */
12428         test_null_burst_operation();
12429         return 0;
12430 }
12431
12432 static int
12433 test_enq_callback_setup(void)
12434 {
12435         struct crypto_testsuite_params *ts_params = &testsuite_params;
12436         struct rte_cryptodev_info dev_info;
12437         struct rte_cryptodev_qp_conf qp_conf = {
12438                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12439         };
12440
12441         struct rte_cryptodev_cb *cb;
12442         uint16_t qp_id = 0;
12443
12444         /* Stop the device in case it's started so it can be configured */
12445         rte_cryptodev_stop(ts_params->valid_devs[0]);
12446
12447         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12448
12449         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12450                         &ts_params->conf),
12451                         "Failed to configure cryptodev %u",
12452                         ts_params->valid_devs[0]);
12453
12454         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12455         qp_conf.mp_session = ts_params->session_mpool;
12456         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12457
12458         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12459                         ts_params->valid_devs[0], qp_id, &qp_conf,
12460                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12461                         "Failed test for "
12462                         "rte_cryptodev_queue_pair_setup: num_inflights "
12463                         "%u on qp %u on cryptodev %u",
12464                         qp_conf.nb_descriptors, qp_id,
12465                         ts_params->valid_devs[0]);
12466
12467         /* Test with invalid crypto device */
12468         cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
12469                         qp_id, test_enq_callback, NULL);
12470         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12471                         "cryptodev %u did not fail",
12472                         qp_id, RTE_CRYPTO_MAX_DEVS);
12473
12474         /* Test with invalid queue pair */
12475         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12476                         dev_info.max_nb_queue_pairs + 1,
12477                         test_enq_callback, NULL);
12478         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12479                         "cryptodev %u did not fail",
12480                         dev_info.max_nb_queue_pairs + 1,
12481                         ts_params->valid_devs[0]);
12482
12483         /* Test with NULL callback */
12484         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12485                         qp_id, NULL, NULL);
12486         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12487                         "cryptodev %u did not fail",
12488                         qp_id, ts_params->valid_devs[0]);
12489
12490         /* Test with valid configuration */
12491         cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
12492                         qp_id, test_enq_callback, NULL);
12493         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12494                         "qp %u on cryptodev %u",
12495                         qp_id, ts_params->valid_devs[0]);
12496
12497         rte_cryptodev_start(ts_params->valid_devs[0]);
12498
12499         /* Launch a thread */
12500         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12501                                 rte_get_next_lcore(-1, 1, 0));
12502
12503         /* Wait until reader exited. */
12504         rte_eal_mp_wait_lcore();
12505
12506         /* Test with invalid crypto device */
12507         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12508                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12509                         "Expected call to fail as crypto device is invalid");
12510
12511         /* Test with invalid queue pair */
12512         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12513                         ts_params->valid_devs[0],
12514                         dev_info.max_nb_queue_pairs + 1, cb),
12515                         "Expected call to fail as queue pair is invalid");
12516
12517         /* Test with NULL callback */
12518         TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
12519                         ts_params->valid_devs[0], qp_id, NULL),
12520                         "Expected call to fail as callback is NULL");
12521
12522         /* Test with valid configuration */
12523         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
12524                         ts_params->valid_devs[0], qp_id, cb),
12525                         "Failed test to remove callback on "
12526                         "qp %u on cryptodev %u",
12527                         qp_id, ts_params->valid_devs[0]);
12528
12529         return TEST_SUCCESS;
12530 }
12531
12532 static int
12533 test_deq_callback_setup(void)
12534 {
12535         struct crypto_testsuite_params *ts_params = &testsuite_params;
12536         struct rte_cryptodev_info dev_info;
12537         struct rte_cryptodev_qp_conf qp_conf = {
12538                 .nb_descriptors = MAX_NUM_OPS_INFLIGHT
12539         };
12540
12541         struct rte_cryptodev_cb *cb;
12542         uint16_t qp_id = 0;
12543
12544         /* Stop the device in case it's started so it can be configured */
12545         rte_cryptodev_stop(ts_params->valid_devs[0]);
12546
12547         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12548
12549         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
12550                         &ts_params->conf),
12551                         "Failed to configure cryptodev %u",
12552                         ts_params->valid_devs[0]);
12553
12554         qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
12555         qp_conf.mp_session = ts_params->session_mpool;
12556         qp_conf.mp_session_private = ts_params->session_priv_mpool;
12557
12558         TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
12559                         ts_params->valid_devs[0], qp_id, &qp_conf,
12560                         rte_cryptodev_socket_id(ts_params->valid_devs[0])),
12561                         "Failed test for "
12562                         "rte_cryptodev_queue_pair_setup: num_inflights "
12563                         "%u on qp %u on cryptodev %u",
12564                         qp_conf.nb_descriptors, qp_id,
12565                         ts_params->valid_devs[0]);
12566
12567         /* Test with invalid crypto device */
12568         cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
12569                         qp_id, test_deq_callback, NULL);
12570         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12571                         "cryptodev %u did not fail",
12572                         qp_id, RTE_CRYPTO_MAX_DEVS);
12573
12574         /* Test with invalid queue pair */
12575         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12576                         dev_info.max_nb_queue_pairs + 1,
12577                         test_deq_callback, NULL);
12578         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12579                         "cryptodev %u did not fail",
12580                         dev_info.max_nb_queue_pairs + 1,
12581                         ts_params->valid_devs[0]);
12582
12583         /* Test with NULL callback */
12584         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12585                         qp_id, NULL, NULL);
12586         TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
12587                         "cryptodev %u did not fail",
12588                         qp_id, ts_params->valid_devs[0]);
12589
12590         /* Test with valid configuration */
12591         cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
12592                         qp_id, test_deq_callback, NULL);
12593         TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
12594                         "qp %u on cryptodev %u",
12595                         qp_id, ts_params->valid_devs[0]);
12596
12597         rte_cryptodev_start(ts_params->valid_devs[0]);
12598
12599         /* Launch a thread */
12600         rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
12601                                 rte_get_next_lcore(-1, 1, 0));
12602
12603         /* Wait until reader exited. */
12604         rte_eal_mp_wait_lcore();
12605
12606         /* Test with invalid crypto device */
12607         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12608                         RTE_CRYPTO_MAX_DEVS, qp_id, cb),
12609                         "Expected call to fail as crypto device is invalid");
12610
12611         /* Test with invalid queue pair */
12612         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12613                         ts_params->valid_devs[0],
12614                         dev_info.max_nb_queue_pairs + 1, cb),
12615                         "Expected call to fail as queue pair is invalid");
12616
12617         /* Test with NULL callback */
12618         TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
12619                         ts_params->valid_devs[0], qp_id, NULL),
12620                         "Expected call to fail as callback is NULL");
12621
12622         /* Test with valid configuration */
12623         TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
12624                         ts_params->valid_devs[0], qp_id, cb),
12625                         "Failed test to remove callback on "
12626                         "qp %u on cryptodev %u",
12627                         qp_id, ts_params->valid_devs[0]);
12628
12629         return TEST_SUCCESS;
12630 }
12631
12632 static void
12633 generate_gmac_large_plaintext(uint8_t *data)
12634 {
12635         uint16_t i;
12636
12637         for (i = 32; i < GMAC_LARGE_PLAINTEXT_LENGTH; i += 32)
12638                 memcpy(&data[i], &data[0], 32);
12639 }
12640
12641 static int
12642 create_gmac_operation(enum rte_crypto_auth_operation op,
12643                 const struct gmac_test_data *tdata)
12644 {
12645         struct crypto_testsuite_params *ts_params = &testsuite_params;
12646         struct crypto_unittest_params *ut_params = &unittest_params;
12647         struct rte_crypto_sym_op *sym_op;
12648
12649         uint32_t plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12650
12651         /* Generate Crypto op data structure */
12652         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12653                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12654         TEST_ASSERT_NOT_NULL(ut_params->op,
12655                         "Failed to allocate symmetric crypto operation struct");
12656
12657         sym_op = ut_params->op->sym;
12658
12659         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
12660                         ut_params->ibuf, tdata->gmac_tag.len);
12661         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12662                         "no room to append digest");
12663
12664         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
12665                         ut_params->ibuf, plaintext_pad_len);
12666
12667         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12668                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12669                                 tdata->gmac_tag.len);
12670                 debug_hexdump(stdout, "digest:",
12671                                 sym_op->auth.digest.data,
12672                                 tdata->gmac_tag.len);
12673         }
12674
12675         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12676                         uint8_t *, IV_OFFSET);
12677
12678         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12679
12680         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12681
12682         sym_op->cipher.data.length = 0;
12683         sym_op->cipher.data.offset = 0;
12684
12685         sym_op->auth.data.offset = 0;
12686         sym_op->auth.data.length = tdata->plaintext.len;
12687
12688         return 0;
12689 }
12690
12691 static int
12692 create_gmac_operation_sgl(enum rte_crypto_auth_operation op,
12693                 const struct gmac_test_data *tdata,
12694                 void *digest_mem, uint64_t digest_phys)
12695 {
12696         struct crypto_testsuite_params *ts_params = &testsuite_params;
12697         struct crypto_unittest_params *ut_params = &unittest_params;
12698         struct rte_crypto_sym_op *sym_op;
12699
12700         /* Generate Crypto op data structure */
12701         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
12702                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
12703         TEST_ASSERT_NOT_NULL(ut_params->op,
12704                         "Failed to allocate symmetric crypto operation struct");
12705
12706         sym_op = ut_params->op->sym;
12707
12708         sym_op->auth.digest.data = digest_mem;
12709         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
12710                         "no room to append digest");
12711
12712         sym_op->auth.digest.phys_addr = digest_phys;
12713
12714         if (op == RTE_CRYPTO_AUTH_OP_VERIFY) {
12715                 rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data,
12716                                 tdata->gmac_tag.len);
12717                 debug_hexdump(stdout, "digest:",
12718                                 sym_op->auth.digest.data,
12719                                 tdata->gmac_tag.len);
12720         }
12721
12722         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
12723                         uint8_t *, IV_OFFSET);
12724
12725         rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len);
12726
12727         debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len);
12728
12729         sym_op->cipher.data.length = 0;
12730         sym_op->cipher.data.offset = 0;
12731
12732         sym_op->auth.data.offset = 0;
12733         sym_op->auth.data.length = tdata->plaintext.len;
12734
12735         return 0;
12736 }
12737
12738 static int create_gmac_session(uint8_t dev_id,
12739                 const struct gmac_test_data *tdata,
12740                 enum rte_crypto_auth_operation auth_op)
12741 {
12742         uint8_t auth_key[tdata->key.len];
12743         int status;
12744
12745         struct crypto_testsuite_params *ts_params = &testsuite_params;
12746         struct crypto_unittest_params *ut_params = &unittest_params;
12747
12748         memcpy(auth_key, tdata->key.data, tdata->key.len);
12749
12750         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12751         ut_params->auth_xform.next = NULL;
12752
12753         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_AES_GMAC;
12754         ut_params->auth_xform.auth.op = auth_op;
12755         ut_params->auth_xform.auth.digest_length = tdata->gmac_tag.len;
12756         ut_params->auth_xform.auth.key.length = tdata->key.len;
12757         ut_params->auth_xform.auth.key.data = auth_key;
12758         ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
12759         ut_params->auth_xform.auth.iv.length = tdata->iv.len;
12760
12761
12762         ut_params->sess = rte_cryptodev_sym_session_create(
12763                         ts_params->session_mpool);
12764         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
12765
12766         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
12767                         &ut_params->auth_xform,
12768                         ts_params->session_priv_mpool);
12769
12770         return status;
12771 }
12772
12773 static int
12774 test_AES_GMAC_authentication(const struct gmac_test_data *tdata)
12775 {
12776         struct crypto_testsuite_params *ts_params = &testsuite_params;
12777         struct crypto_unittest_params *ut_params = &unittest_params;
12778         struct rte_cryptodev_info dev_info;
12779
12780         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12781         uint64_t feat_flags = dev_info.feature_flags;
12782
12783         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12784                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12785                 printf("Device doesn't support RAW data-path APIs.\n");
12786                 return TEST_SKIPPED;
12787         }
12788
12789         int retval;
12790
12791         uint8_t *auth_tag, *plaintext;
12792         uint16_t plaintext_pad_len;
12793
12794         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12795                               "No GMAC length in the source data");
12796
12797         /* Verify the capabilities */
12798         struct rte_cryptodev_sym_capability_idx cap_idx;
12799         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12800         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12801         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12802                         &cap_idx) == NULL)
12803                 return TEST_SKIPPED;
12804
12805         retval = create_gmac_session(ts_params->valid_devs[0],
12806                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
12807
12808         if (retval == -ENOTSUP)
12809                 return TEST_SKIPPED;
12810         if (retval < 0)
12811                 return retval;
12812
12813         if (tdata->plaintext.len > MBUF_SIZE)
12814                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12815         else
12816                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12817         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12818                         "Failed to allocate input buffer in mempool");
12819
12820         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12821                         rte_pktmbuf_tailroom(ut_params->ibuf));
12822
12823         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12824         /*
12825          * Runtime generate the large plain text instead of use hard code
12826          * plain text vector. It is done to avoid create huge source file
12827          * with the test vector.
12828          */
12829         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12830                 generate_gmac_large_plaintext(tdata->plaintext.data);
12831
12832         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12833                                 plaintext_pad_len);
12834         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12835
12836         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12837         debug_hexdump(stdout, "plaintext:", plaintext,
12838                         tdata->plaintext.len);
12839
12840         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_GENERATE,
12841                         tdata);
12842
12843         if (retval < 0)
12844                 return retval;
12845
12846         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12847
12848         ut_params->op->sym->m_src = ut_params->ibuf;
12849
12850         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12851                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12852                         ut_params->op);
12853         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12854                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12855                                 ut_params->op, 0, 1, 0, 0);
12856         else
12857                 TEST_ASSERT_NOT_NULL(
12858                         process_crypto_request(ts_params->valid_devs[0],
12859                         ut_params->op), "failed to process sym crypto op");
12860
12861         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12862                         "crypto op processing failed");
12863
12864         if (ut_params->op->sym->m_dst) {
12865                 auth_tag = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
12866                                 uint8_t *, plaintext_pad_len);
12867         } else {
12868                 auth_tag = plaintext + plaintext_pad_len;
12869         }
12870
12871         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
12872
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 static int
12883 test_AES_GMAC_authentication_test_case_1(void)
12884 {
12885         return test_AES_GMAC_authentication(&gmac_test_case_1);
12886 }
12887
12888 static int
12889 test_AES_GMAC_authentication_test_case_2(void)
12890 {
12891         return test_AES_GMAC_authentication(&gmac_test_case_2);
12892 }
12893
12894 static int
12895 test_AES_GMAC_authentication_test_case_3(void)
12896 {
12897         return test_AES_GMAC_authentication(&gmac_test_case_3);
12898 }
12899
12900 static int
12901 test_AES_GMAC_authentication_test_case_4(void)
12902 {
12903         return test_AES_GMAC_authentication(&gmac_test_case_4);
12904 }
12905
12906 static int
12907 test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata)
12908 {
12909         struct crypto_testsuite_params *ts_params = &testsuite_params;
12910         struct crypto_unittest_params *ut_params = &unittest_params;
12911         int retval;
12912         uint32_t plaintext_pad_len;
12913         uint8_t *plaintext;
12914         struct rte_cryptodev_info dev_info;
12915
12916         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
12917         uint64_t feat_flags = dev_info.feature_flags;
12918
12919         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
12920                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
12921                 printf("Device doesn't support RAW data-path APIs.\n");
12922                 return TEST_SKIPPED;
12923         }
12924
12925         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
12926                               "No GMAC length in the source data");
12927
12928         /* Verify the capabilities */
12929         struct rte_cryptodev_sym_capability_idx cap_idx;
12930         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
12931         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
12932         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
12933                         &cap_idx) == NULL)
12934                 return TEST_SKIPPED;
12935
12936         retval = create_gmac_session(ts_params->valid_devs[0],
12937                         tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
12938
12939         if (retval == -ENOTSUP)
12940                 return TEST_SKIPPED;
12941         if (retval < 0)
12942                 return retval;
12943
12944         if (tdata->plaintext.len > MBUF_SIZE)
12945                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->large_mbuf_pool);
12946         else
12947                 ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
12948         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
12949                         "Failed to allocate input buffer in mempool");
12950
12951         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
12952                         rte_pktmbuf_tailroom(ut_params->ibuf));
12953
12954         plaintext_pad_len = RTE_ALIGN_CEIL(tdata->plaintext.len, 16);
12955
12956         /*
12957          * Runtime generate the large plain text instead of use hard code
12958          * plain text vector. It is done to avoid create huge source file
12959          * with the test vector.
12960          */
12961         if (tdata->plaintext.len == GMAC_LARGE_PLAINTEXT_LENGTH)
12962                 generate_gmac_large_plaintext(tdata->plaintext.data);
12963
12964         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
12965                                 plaintext_pad_len);
12966         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
12967
12968         memcpy(plaintext, tdata->plaintext.data, tdata->plaintext.len);
12969         debug_hexdump(stdout, "plaintext:", plaintext,
12970                         tdata->plaintext.len);
12971
12972         retval = create_gmac_operation(RTE_CRYPTO_AUTH_OP_VERIFY,
12973                         tdata);
12974
12975         if (retval < 0)
12976                 return retval;
12977
12978         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
12979
12980         ut_params->op->sym->m_src = ut_params->ibuf;
12981
12982         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
12983                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
12984                         ut_params->op);
12985         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
12986                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
12987                                 ut_params->op, 0, 1, 0, 0);
12988         else
12989                 TEST_ASSERT_NOT_NULL(
12990                         process_crypto_request(ts_params->valid_devs[0],
12991                         ut_params->op), "failed to process sym crypto op");
12992
12993         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
12994                         "crypto op processing failed");
12995
12996         return 0;
12997
12998 }
12999
13000 static int
13001 test_AES_GMAC_authentication_verify_test_case_1(void)
13002 {
13003         return test_AES_GMAC_authentication_verify(&gmac_test_case_1);
13004 }
13005
13006 static int
13007 test_AES_GMAC_authentication_verify_test_case_2(void)
13008 {
13009         return test_AES_GMAC_authentication_verify(&gmac_test_case_2);
13010 }
13011
13012 static int
13013 test_AES_GMAC_authentication_verify_test_case_3(void)
13014 {
13015         return test_AES_GMAC_authentication_verify(&gmac_test_case_3);
13016 }
13017
13018 static int
13019 test_AES_GMAC_authentication_verify_test_case_4(void)
13020 {
13021         return test_AES_GMAC_authentication_verify(&gmac_test_case_4);
13022 }
13023
13024 static int
13025 test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
13026                                 uint32_t fragsz)
13027 {
13028         struct crypto_testsuite_params *ts_params = &testsuite_params;
13029         struct crypto_unittest_params *ut_params = &unittest_params;
13030         struct rte_cryptodev_info dev_info;
13031         uint64_t feature_flags;
13032         unsigned int trn_data = 0;
13033         void *digest_mem = NULL;
13034         uint32_t segs = 1;
13035         unsigned int to_trn = 0;
13036         struct rte_mbuf *buf = NULL;
13037         uint8_t *auth_tag, *plaintext;
13038         int retval;
13039
13040         TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
13041                               "No GMAC length in the source data");
13042
13043         /* Verify the capabilities */
13044         struct rte_cryptodev_sym_capability_idx cap_idx;
13045         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13046         cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
13047         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13048                         &cap_idx) == NULL)
13049                 return TEST_SKIPPED;
13050
13051         /* Check for any input SGL support */
13052         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13053         feature_flags = dev_info.feature_flags;
13054
13055         if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
13056                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
13057                         (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
13058                 return TEST_SKIPPED;
13059
13060         if (fragsz > tdata->plaintext.len)
13061                 fragsz = tdata->plaintext.len;
13062
13063         uint16_t plaintext_len = fragsz;
13064
13065         retval = create_gmac_session(ts_params->valid_devs[0],
13066                         tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
13067
13068         if (retval == -ENOTSUP)
13069                 return TEST_SKIPPED;
13070         if (retval < 0)
13071                 return retval;
13072
13073         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13074         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13075                         "Failed to allocate input buffer in mempool");
13076
13077         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13078                         rte_pktmbuf_tailroom(ut_params->ibuf));
13079
13080         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13081                                 plaintext_len);
13082         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13083
13084         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
13085
13086         trn_data += plaintext_len;
13087
13088         buf = ut_params->ibuf;
13089
13090         /*
13091          * Loop until no more fragments
13092          */
13093
13094         while (trn_data < tdata->plaintext.len) {
13095                 ++segs;
13096                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
13097                                 (tdata->plaintext.len - trn_data) : fragsz;
13098
13099                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13100                 buf = buf->next;
13101
13102                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
13103                                 rte_pktmbuf_tailroom(buf));
13104
13105                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
13106                                 to_trn);
13107
13108                 memcpy(plaintext, tdata->plaintext.data + trn_data,
13109                                 to_trn);
13110                 trn_data += to_trn;
13111                 if (trn_data  == tdata->plaintext.len)
13112                         digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
13113                                         tdata->gmac_tag.len);
13114         }
13115         ut_params->ibuf->nb_segs = segs;
13116
13117         /*
13118          * Place digest at the end of the last buffer
13119          */
13120         uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn;
13121
13122         if (!digest_mem) {
13123                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13124                                 + tdata->gmac_tag.len);
13125                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
13126                                 tdata->plaintext.len);
13127         }
13128
13129         retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE,
13130                         tdata, digest_mem, digest_phys);
13131
13132         if (retval < 0)
13133                 return retval;
13134
13135         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13136
13137         ut_params->op->sym->m_src = ut_params->ibuf;
13138
13139         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
13140                 return TEST_SKIPPED;
13141
13142         TEST_ASSERT_NOT_NULL(
13143                 process_crypto_request(ts_params->valid_devs[0],
13144                 ut_params->op), "failed to process sym crypto op");
13145
13146         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
13147                         "crypto op processing failed");
13148
13149         auth_tag = digest_mem;
13150         debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len);
13151         TEST_ASSERT_BUFFERS_ARE_EQUAL(
13152                         auth_tag,
13153                         tdata->gmac_tag.data,
13154                         tdata->gmac_tag.len,
13155                         "GMAC Generated auth tag not as expected");
13156
13157         return 0;
13158 }
13159
13160 /* Segment size not multiple of block size (16B) */
13161 static int
13162 test_AES_GMAC_authentication_SGL_40B(void)
13163 {
13164         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40);
13165 }
13166
13167 static int
13168 test_AES_GMAC_authentication_SGL_80B(void)
13169 {
13170         return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80);
13171 }
13172
13173 static int
13174 test_AES_GMAC_authentication_SGL_2048B(void)
13175 {
13176         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048);
13177 }
13178
13179 /* Segment size not multiple of block size (16B) */
13180 static int
13181 test_AES_GMAC_authentication_SGL_2047B(void)
13182 {
13183         return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047);
13184 }
13185
13186 struct test_crypto_vector {
13187         enum rte_crypto_cipher_algorithm crypto_algo;
13188         unsigned int cipher_offset;
13189         unsigned int cipher_len;
13190
13191         struct {
13192                 uint8_t data[64];
13193                 unsigned int len;
13194         } cipher_key;
13195
13196         struct {
13197                 uint8_t data[64];
13198                 unsigned int len;
13199         } iv;
13200
13201         struct {
13202                 const uint8_t *data;
13203                 unsigned int len;
13204         } plaintext;
13205
13206         struct {
13207                 const uint8_t *data;
13208                 unsigned int len;
13209         } ciphertext;
13210
13211         enum rte_crypto_auth_algorithm auth_algo;
13212         unsigned int auth_offset;
13213
13214         struct {
13215                 uint8_t data[128];
13216                 unsigned int len;
13217         } auth_key;
13218
13219         struct {
13220                 const uint8_t *data;
13221                 unsigned int len;
13222         } aad;
13223
13224         struct {
13225                 uint8_t data[128];
13226                 unsigned int len;
13227         } digest;
13228 };
13229
13230 static const struct test_crypto_vector
13231 hmac_sha1_test_crypto_vector = {
13232         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13233         .plaintext = {
13234                 .data = plaintext_hash,
13235                 .len = 512
13236         },
13237         .auth_key = {
13238                 .data = {
13239                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13240                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13241                         0xDE, 0xF4, 0xDE, 0xAD
13242                 },
13243                 .len = 20
13244         },
13245         .digest = {
13246                 .data = {
13247                         0xC4, 0xB7, 0x0E, 0x6B, 0xDE, 0xD1, 0xE7, 0x77,
13248                         0x7E, 0x2E, 0x8F, 0xFC, 0x48, 0x39, 0x46, 0x17,
13249                         0x3F, 0x91, 0x64, 0x59
13250                 },
13251                 .len = 20
13252         }
13253 };
13254
13255 static const struct test_crypto_vector
13256 aes128_gmac_test_vector = {
13257         .auth_algo = RTE_CRYPTO_AUTH_AES_GMAC,
13258         .plaintext = {
13259                 .data = plaintext_hash,
13260                 .len = 512
13261         },
13262         .iv = {
13263                 .data = {
13264                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13265                         0x08, 0x09, 0x0A, 0x0B
13266                 },
13267                 .len = 12
13268         },
13269         .auth_key = {
13270                 .data = {
13271                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13272                         0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA
13273                 },
13274                 .len = 16
13275         },
13276         .digest = {
13277                 .data = {
13278                         0xCA, 0x00, 0x99, 0x8B, 0x30, 0x7E, 0x74, 0x56,
13279                         0x32, 0xA7, 0x87, 0xB5, 0xE9, 0xB2, 0x34, 0x5A
13280                 },
13281                 .len = 16
13282         }
13283 };
13284
13285 static const struct test_crypto_vector
13286 aes128cbc_hmac_sha1_test_vector = {
13287         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13288         .cipher_offset = 0,
13289         .cipher_len = 512,
13290         .cipher_key = {
13291                 .data = {
13292                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13293                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13294                 },
13295                 .len = 16
13296         },
13297         .iv = {
13298                 .data = {
13299                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13300                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13301                 },
13302                 .len = 16
13303         },
13304         .plaintext = {
13305                 .data = plaintext_hash,
13306                 .len = 512
13307         },
13308         .ciphertext = {
13309                 .data = ciphertext512_aes128cbc,
13310                 .len = 512
13311         },
13312         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13313         .auth_offset = 0,
13314         .auth_key = {
13315                 .data = {
13316                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13317                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13318                         0xDE, 0xF4, 0xDE, 0xAD
13319                 },
13320                 .len = 20
13321         },
13322         .digest = {
13323                 .data = {
13324                         0x9A, 0x4F, 0x88, 0x1B, 0xB6, 0x8F, 0xD8, 0x60,
13325                         0x42, 0x1A, 0x7D, 0x3D, 0xF5, 0x82, 0x80, 0xF1,
13326                         0x18, 0x8C, 0x1D, 0x32
13327                 },
13328                 .len = 20
13329         }
13330 };
13331
13332 static const struct test_crypto_vector
13333 aes128cbc_hmac_sha1_aad_test_vector = {
13334         .crypto_algo = RTE_CRYPTO_CIPHER_AES_CBC,
13335         .cipher_offset = 8,
13336         .cipher_len = 496,
13337         .cipher_key = {
13338                 .data = {
13339                         0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
13340                         0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
13341                 },
13342                 .len = 16
13343         },
13344         .iv = {
13345                 .data = {
13346                         0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
13347                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
13348                 },
13349                 .len = 16
13350         },
13351         .plaintext = {
13352                 .data = plaintext_hash,
13353                 .len = 512
13354         },
13355         .ciphertext = {
13356                 .data = ciphertext512_aes128cbc_aad,
13357                 .len = 512
13358         },
13359         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
13360         .auth_offset = 0,
13361         .auth_key = {
13362                 .data = {
13363                         0xF8, 0x2A, 0xC7, 0x54, 0xDB, 0x96, 0x18, 0xAA,
13364                         0xC3, 0xA1, 0x53, 0xF6, 0x1F, 0x17, 0x60, 0xBD,
13365                         0xDE, 0xF4, 0xDE, 0xAD
13366                 },
13367                 .len = 20
13368         },
13369         .digest = {
13370                 .data = {
13371                         0x6D, 0xF3, 0x50, 0x79, 0x7A, 0x2A, 0xAC, 0x7F,
13372                         0xA6, 0xF0, 0xC6, 0x38, 0x1F, 0xA4, 0xDD, 0x9B,
13373                         0x62, 0x0F, 0xFB, 0x10
13374                 },
13375                 .len = 20
13376         }
13377 };
13378
13379 static void
13380 data_corruption(uint8_t *data)
13381 {
13382         data[0] += 1;
13383 }
13384
13385 static void
13386 tag_corruption(uint8_t *data, unsigned int tag_offset)
13387 {
13388         data[tag_offset] += 1;
13389 }
13390
13391 static int
13392 create_auth_session(struct crypto_unittest_params *ut_params,
13393                 uint8_t dev_id,
13394                 const struct test_crypto_vector *reference,
13395                 enum rte_crypto_auth_operation auth_op)
13396 {
13397         struct crypto_testsuite_params *ts_params = &testsuite_params;
13398         uint8_t auth_key[reference->auth_key.len + 1];
13399         int status;
13400
13401         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13402
13403         /* Setup Authentication Parameters */
13404         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13405         ut_params->auth_xform.auth.op = auth_op;
13406         ut_params->auth_xform.next = NULL;
13407         ut_params->auth_xform.auth.algo = reference->auth_algo;
13408         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13409         ut_params->auth_xform.auth.key.data = auth_key;
13410         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13411
13412         /* Create Crypto session*/
13413         ut_params->sess = rte_cryptodev_sym_session_create(
13414                         ts_params->session_mpool);
13415         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13416
13417         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13418                                 &ut_params->auth_xform,
13419                                 ts_params->session_priv_mpool);
13420
13421         return status;
13422 }
13423
13424 static int
13425 create_auth_cipher_session(struct crypto_unittest_params *ut_params,
13426                 uint8_t dev_id,
13427                 const struct test_crypto_vector *reference,
13428                 enum rte_crypto_auth_operation auth_op,
13429                 enum rte_crypto_cipher_operation cipher_op)
13430 {
13431         struct crypto_testsuite_params *ts_params = &testsuite_params;
13432         uint8_t cipher_key[reference->cipher_key.len + 1];
13433         uint8_t auth_key[reference->auth_key.len + 1];
13434         int status;
13435
13436         memcpy(cipher_key, reference->cipher_key.data,
13437                         reference->cipher_key.len);
13438         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13439
13440         /* Setup Authentication Parameters */
13441         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13442         ut_params->auth_xform.auth.op = auth_op;
13443         ut_params->auth_xform.auth.algo = reference->auth_algo;
13444         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13445         ut_params->auth_xform.auth.key.data = auth_key;
13446         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13447
13448         if (reference->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) {
13449                 ut_params->auth_xform.auth.iv.offset = IV_OFFSET;
13450                 ut_params->auth_xform.auth.iv.length = reference->iv.len;
13451         } else {
13452                 ut_params->auth_xform.next = &ut_params->cipher_xform;
13453
13454                 /* Setup Cipher Parameters */
13455                 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13456                 ut_params->cipher_xform.next = NULL;
13457                 ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13458                 ut_params->cipher_xform.cipher.op = cipher_op;
13459                 ut_params->cipher_xform.cipher.key.data = cipher_key;
13460                 ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13461                 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13462                 ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13463         }
13464
13465         /* Create Crypto session*/
13466         ut_params->sess = rte_cryptodev_sym_session_create(
13467                         ts_params->session_mpool);
13468         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13469
13470         status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess,
13471                                 &ut_params->auth_xform,
13472                                 ts_params->session_priv_mpool);
13473
13474         return status;
13475 }
13476
13477 static int
13478 create_auth_operation(struct crypto_testsuite_params *ts_params,
13479                 struct crypto_unittest_params *ut_params,
13480                 const struct test_crypto_vector *reference,
13481                 unsigned int auth_generate)
13482 {
13483         /* Generate Crypto op data structure */
13484         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13485                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13486         TEST_ASSERT_NOT_NULL(ut_params->op,
13487                         "Failed to allocate pktmbuf offload");
13488
13489         /* Set crypto operation data parameters */
13490         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13491
13492         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13493
13494         /* set crypto operation source mbuf */
13495         sym_op->m_src = ut_params->ibuf;
13496
13497         /* digest */
13498         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13499                         ut_params->ibuf, reference->digest.len);
13500
13501         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13502                         "no room to append auth tag");
13503
13504         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13505                         ut_params->ibuf, reference->plaintext.len);
13506
13507         if (auth_generate)
13508                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13509         else
13510                 memcpy(sym_op->auth.digest.data,
13511                                 reference->digest.data,
13512                                 reference->digest.len);
13513
13514         debug_hexdump(stdout, "digest:",
13515                         sym_op->auth.digest.data,
13516                         reference->digest.len);
13517
13518         sym_op->auth.data.length = reference->plaintext.len;
13519         sym_op->auth.data.offset = 0;
13520
13521         return 0;
13522 }
13523
13524 static int
13525 create_auth_GMAC_operation(struct crypto_testsuite_params *ts_params,
13526                 struct crypto_unittest_params *ut_params,
13527                 const struct test_crypto_vector *reference,
13528                 unsigned int auth_generate)
13529 {
13530         /* Generate Crypto op data structure */
13531         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13532                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13533         TEST_ASSERT_NOT_NULL(ut_params->op,
13534                         "Failed to allocate pktmbuf offload");
13535
13536         /* Set crypto operation data parameters */
13537         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13538
13539         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13540
13541         /* set crypto operation source mbuf */
13542         sym_op->m_src = ut_params->ibuf;
13543
13544         /* digest */
13545         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13546                         ut_params->ibuf, reference->digest.len);
13547
13548         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13549                         "no room to append auth tag");
13550
13551         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13552                         ut_params->ibuf, reference->ciphertext.len);
13553
13554         if (auth_generate)
13555                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13556         else
13557                 memcpy(sym_op->auth.digest.data,
13558                                 reference->digest.data,
13559                                 reference->digest.len);
13560
13561         debug_hexdump(stdout, "digest:",
13562                         sym_op->auth.digest.data,
13563                         reference->digest.len);
13564
13565         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13566                         reference->iv.data, reference->iv.len);
13567
13568         sym_op->cipher.data.length = 0;
13569         sym_op->cipher.data.offset = 0;
13570
13571         sym_op->auth.data.length = reference->plaintext.len;
13572         sym_op->auth.data.offset = 0;
13573
13574         return 0;
13575 }
13576
13577 static int
13578 create_cipher_auth_operation(struct crypto_testsuite_params *ts_params,
13579                 struct crypto_unittest_params *ut_params,
13580                 const struct test_crypto_vector *reference,
13581                 unsigned int auth_generate)
13582 {
13583         /* Generate Crypto op data structure */
13584         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
13585                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
13586         TEST_ASSERT_NOT_NULL(ut_params->op,
13587                         "Failed to allocate pktmbuf offload");
13588
13589         /* Set crypto operation data parameters */
13590         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
13591
13592         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
13593
13594         /* set crypto operation source mbuf */
13595         sym_op->m_src = ut_params->ibuf;
13596
13597         /* digest */
13598         sym_op->auth.digest.data = (uint8_t *)rte_pktmbuf_append(
13599                         ut_params->ibuf, reference->digest.len);
13600
13601         TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data,
13602                         "no room to append auth tag");
13603
13604         sym_op->auth.digest.phys_addr = rte_pktmbuf_iova_offset(
13605                         ut_params->ibuf, reference->ciphertext.len);
13606
13607         if (auth_generate)
13608                 memset(sym_op->auth.digest.data, 0, reference->digest.len);
13609         else
13610                 memcpy(sym_op->auth.digest.data,
13611                                 reference->digest.data,
13612                                 reference->digest.len);
13613
13614         debug_hexdump(stdout, "digest:",
13615                         sym_op->auth.digest.data,
13616                         reference->digest.len);
13617
13618         rte_memcpy(rte_crypto_op_ctod_offset(ut_params->op, uint8_t *, IV_OFFSET),
13619                         reference->iv.data, reference->iv.len);
13620
13621         sym_op->cipher.data.length = reference->cipher_len;
13622         sym_op->cipher.data.offset = reference->cipher_offset;
13623
13624         sym_op->auth.data.length = reference->plaintext.len;
13625         sym_op->auth.data.offset = reference->auth_offset;
13626
13627         return 0;
13628 }
13629
13630 static int
13631 create_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13632                 struct crypto_unittest_params *ut_params,
13633                 const struct test_crypto_vector *reference)
13634 {
13635         return create_auth_operation(ts_params, ut_params, reference, 0);
13636 }
13637
13638 static int
13639 create_auth_verify_GMAC_operation(
13640                 struct crypto_testsuite_params *ts_params,
13641                 struct crypto_unittest_params *ut_params,
13642                 const struct test_crypto_vector *reference)
13643 {
13644         return create_auth_GMAC_operation(ts_params, ut_params, reference, 0);
13645 }
13646
13647 static int
13648 create_cipher_auth_verify_operation(struct crypto_testsuite_params *ts_params,
13649                 struct crypto_unittest_params *ut_params,
13650                 const struct test_crypto_vector *reference)
13651 {
13652         return create_cipher_auth_operation(ts_params, ut_params, reference, 0);
13653 }
13654
13655 static int
13656 test_authentication_verify_fail_when_data_corruption(
13657                 struct crypto_testsuite_params *ts_params,
13658                 struct crypto_unittest_params *ut_params,
13659                 const struct test_crypto_vector *reference,
13660                 unsigned int data_corrupted)
13661 {
13662         int retval;
13663
13664         uint8_t *plaintext;
13665         struct rte_cryptodev_info dev_info;
13666
13667         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13668         uint64_t feat_flags = dev_info.feature_flags;
13669
13670         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13671                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13672                 printf("Device doesn't support RAW data-path APIs.\n");
13673                 return TEST_SKIPPED;
13674         }
13675
13676         /* Verify the capabilities */
13677         struct rte_cryptodev_sym_capability_idx cap_idx;
13678         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13679         cap_idx.algo.auth = reference->auth_algo;
13680         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13681                         &cap_idx) == NULL)
13682                 return TEST_SKIPPED;
13683
13684
13685         /* Create session */
13686         retval = create_auth_session(ut_params,
13687                         ts_params->valid_devs[0],
13688                         reference,
13689                         RTE_CRYPTO_AUTH_OP_VERIFY);
13690
13691         if (retval == -ENOTSUP)
13692                 return TEST_SKIPPED;
13693         if (retval < 0)
13694                 return retval;
13695
13696         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13697         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13698                         "Failed to allocate input buffer in mempool");
13699
13700         /* clear mbuf payload */
13701         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13702                         rte_pktmbuf_tailroom(ut_params->ibuf));
13703
13704         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13705                         reference->plaintext.len);
13706         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13707         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13708
13709         debug_hexdump(stdout, "plaintext:", plaintext,
13710                 reference->plaintext.len);
13711
13712         /* Create operation */
13713         retval = create_auth_verify_operation(ts_params, ut_params, reference);
13714
13715         if (retval < 0)
13716                 return retval;
13717
13718         if (data_corrupted)
13719                 data_corruption(plaintext);
13720         else
13721                 tag_corruption(plaintext, reference->plaintext.len);
13722
13723         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13724                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13725                         ut_params->op);
13726                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13727                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13728                         "authentication not failed");
13729         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13730                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13731                                 ut_params->op, 0, 1, 0, 0);
13732         else {
13733                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13734                         ut_params->op);
13735         }
13736         if (ut_params->op == NULL)
13737                 return 0;
13738         else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
13739                 return 0;
13740
13741         return -1;
13742 }
13743
13744 static int
13745 test_authentication_verify_GMAC_fail_when_corruption(
13746                 struct crypto_testsuite_params *ts_params,
13747                 struct crypto_unittest_params *ut_params,
13748                 const struct test_crypto_vector *reference,
13749                 unsigned int data_corrupted)
13750 {
13751         int retval;
13752         uint8_t *plaintext;
13753         struct rte_cryptodev_info dev_info;
13754
13755         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13756         uint64_t feat_flags = dev_info.feature_flags;
13757
13758         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13759                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13760                 printf("Device doesn't support RAW data-path APIs.\n");
13761                 return TEST_SKIPPED;
13762         }
13763
13764         /* Verify the capabilities */
13765         struct rte_cryptodev_sym_capability_idx cap_idx;
13766         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13767         cap_idx.algo.auth = reference->auth_algo;
13768         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13769                         &cap_idx) == NULL)
13770                 return TEST_SKIPPED;
13771
13772         /* Create session */
13773         retval = create_auth_cipher_session(ut_params,
13774                         ts_params->valid_devs[0],
13775                         reference,
13776                         RTE_CRYPTO_AUTH_OP_VERIFY,
13777                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13778         if (retval < 0)
13779                 return retval;
13780
13781         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13782         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13783                         "Failed to allocate input buffer in mempool");
13784
13785         /* clear mbuf payload */
13786         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13787                         rte_pktmbuf_tailroom(ut_params->ibuf));
13788
13789         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13790                         reference->plaintext.len);
13791         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
13792         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
13793
13794         debug_hexdump(stdout, "plaintext:", plaintext,
13795                 reference->plaintext.len);
13796
13797         /* Create operation */
13798         retval = create_auth_verify_GMAC_operation(ts_params,
13799                         ut_params,
13800                         reference);
13801
13802         if (retval < 0)
13803                 return retval;
13804
13805         if (data_corrupted)
13806                 data_corruption(plaintext);
13807         else
13808                 tag_corruption(plaintext, reference->aad.len);
13809
13810         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13811                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13812                         ut_params->op);
13813                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13814                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13815                         "authentication not failed");
13816         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13817                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13818                                 ut_params->op, 0, 1, 0, 0);
13819         else {
13820                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13821                         ut_params->op);
13822                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13823         }
13824
13825         return 0;
13826 }
13827
13828 static int
13829 test_authenticated_decryption_fail_when_corruption(
13830                 struct crypto_testsuite_params *ts_params,
13831                 struct crypto_unittest_params *ut_params,
13832                 const struct test_crypto_vector *reference,
13833                 unsigned int data_corrupted)
13834 {
13835         int retval;
13836
13837         uint8_t *ciphertext;
13838         struct rte_cryptodev_info dev_info;
13839
13840         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13841         uint64_t feat_flags = dev_info.feature_flags;
13842
13843         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13844                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13845                 printf("Device doesn't support RAW data-path APIs.\n");
13846                 return TEST_SKIPPED;
13847         }
13848
13849         /* Verify the capabilities */
13850         struct rte_cryptodev_sym_capability_idx cap_idx;
13851         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13852         cap_idx.algo.auth = reference->auth_algo;
13853         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13854                         &cap_idx) == NULL)
13855                 return TEST_SKIPPED;
13856         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13857         cap_idx.algo.cipher = reference->crypto_algo;
13858         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13859                         &cap_idx) == NULL)
13860                 return TEST_SKIPPED;
13861
13862         /* Create session */
13863         retval = create_auth_cipher_session(ut_params,
13864                         ts_params->valid_devs[0],
13865                         reference,
13866                         RTE_CRYPTO_AUTH_OP_VERIFY,
13867                         RTE_CRYPTO_CIPHER_OP_DECRYPT);
13868
13869         if (retval == -ENOTSUP)
13870                 return TEST_SKIPPED;
13871         if (retval < 0)
13872                 return retval;
13873
13874         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13875         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13876                         "Failed to allocate input buffer in mempool");
13877
13878         /* clear mbuf payload */
13879         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
13880                         rte_pktmbuf_tailroom(ut_params->ibuf));
13881
13882         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
13883                         reference->ciphertext.len);
13884         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
13885         memcpy(ciphertext, reference->ciphertext.data,
13886                         reference->ciphertext.len);
13887
13888         /* Create operation */
13889         retval = create_cipher_auth_verify_operation(ts_params,
13890                         ut_params,
13891                         reference);
13892
13893         if (retval < 0)
13894                 return retval;
13895
13896         if (data_corrupted)
13897                 data_corruption(ciphertext);
13898         else
13899                 tag_corruption(ciphertext, reference->ciphertext.len);
13900
13901         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) {
13902                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
13903                         ut_params->op);
13904                 TEST_ASSERT_NOT_EQUAL(ut_params->op->status,
13905                         RTE_CRYPTO_OP_STATUS_SUCCESS,
13906                         "authentication not failed");
13907         } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
13908                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
13909                                 ut_params->op, 1, 1, 0, 0);
13910         else {
13911                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
13912                         ut_params->op);
13913                 TEST_ASSERT_NULL(ut_params->op, "authentication not failed");
13914         }
13915
13916         return 0;
13917 }
13918
13919 static int
13920 test_authenticated_encrypt_with_esn(
13921                 struct crypto_testsuite_params *ts_params,
13922                 struct crypto_unittest_params *ut_params,
13923                 const struct test_crypto_vector *reference)
13924 {
13925         int retval;
13926
13927         uint8_t *authciphertext, *plaintext, *auth_tag;
13928         uint16_t plaintext_pad_len;
13929         uint8_t cipher_key[reference->cipher_key.len + 1];
13930         uint8_t auth_key[reference->auth_key.len + 1];
13931         struct rte_cryptodev_info dev_info;
13932         int status;
13933
13934         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
13935         uint64_t feat_flags = dev_info.feature_flags;
13936
13937         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
13938                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
13939                 printf("Device doesn't support RAW data-path APIs.\n");
13940                 return TEST_SKIPPED;
13941         }
13942
13943         /* Verify the capabilities */
13944         struct rte_cryptodev_sym_capability_idx cap_idx;
13945         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13946         cap_idx.algo.auth = reference->auth_algo;
13947         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13948                         &cap_idx) == NULL)
13949                 return TEST_SKIPPED;
13950         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13951         cap_idx.algo.cipher = reference->crypto_algo;
13952         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
13953                         &cap_idx) == NULL)
13954                 return TEST_SKIPPED;
13955
13956         /* Create session */
13957         memcpy(cipher_key, reference->cipher_key.data,
13958                         reference->cipher_key.len);
13959         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
13960
13961         /* Setup Cipher Parameters */
13962         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
13963         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
13964         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
13965         ut_params->cipher_xform.cipher.key.data = cipher_key;
13966         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
13967         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
13968         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
13969
13970         ut_params->cipher_xform.next = &ut_params->auth_xform;
13971
13972         /* Setup Authentication Parameters */
13973         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
13974         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
13975         ut_params->auth_xform.auth.algo = reference->auth_algo;
13976         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
13977         ut_params->auth_xform.auth.key.data = auth_key;
13978         ut_params->auth_xform.auth.digest_length = reference->digest.len;
13979         ut_params->auth_xform.next = NULL;
13980
13981         /* Create Crypto session*/
13982         ut_params->sess = rte_cryptodev_sym_session_create(
13983                         ts_params->session_mpool);
13984         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
13985
13986         status = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
13987                                 ut_params->sess,
13988                                 &ut_params->cipher_xform,
13989                                 ts_params->session_priv_mpool);
13990
13991         if (status == -ENOTSUP)
13992                 return TEST_SKIPPED;
13993
13994         TEST_ASSERT_EQUAL(status, 0, "Session init failed");
13995
13996         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
13997         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
13998                         "Failed to allocate input buffer in mempool");
13999
14000         /* clear mbuf payload */
14001         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14002                         rte_pktmbuf_tailroom(ut_params->ibuf));
14003
14004         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14005                         reference->plaintext.len);
14006         TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext");
14007         memcpy(plaintext, reference->plaintext.data, reference->plaintext.len);
14008
14009         /* Create operation */
14010         retval = create_cipher_auth_operation(ts_params,
14011                         ut_params,
14012                         reference, 0);
14013
14014         if (retval < 0)
14015                 return retval;
14016
14017         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14018                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14019                         ut_params->op);
14020         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14021                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14022                                 ut_params->op, 1, 1, 0, 0);
14023         else
14024                 ut_params->op = process_crypto_request(
14025                         ts_params->valid_devs[0], ut_params->op);
14026
14027         TEST_ASSERT_NOT_NULL(ut_params->op, "no crypto operation returned");
14028
14029         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14030                         "crypto op processing failed");
14031
14032         plaintext_pad_len = RTE_ALIGN_CEIL(reference->plaintext.len, 16);
14033
14034         authciphertext = rte_pktmbuf_mtod_offset(ut_params->ibuf, uint8_t *,
14035                         ut_params->op->sym->auth.data.offset);
14036         auth_tag = authciphertext + plaintext_pad_len;
14037         debug_hexdump(stdout, "ciphertext:", authciphertext,
14038                         reference->ciphertext.len);
14039         debug_hexdump(stdout, "auth tag:", auth_tag, reference->digest.len);
14040
14041         /* Validate obuf */
14042         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14043                         authciphertext,
14044                         reference->ciphertext.data,
14045                         reference->ciphertext.len,
14046                         "Ciphertext data not as expected");
14047
14048         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14049                         auth_tag,
14050                         reference->digest.data,
14051                         reference->digest.len,
14052                         "Generated digest not as expected");
14053
14054         return TEST_SUCCESS;
14055
14056 }
14057
14058 static int
14059 test_authenticated_decrypt_with_esn(
14060                 struct crypto_testsuite_params *ts_params,
14061                 struct crypto_unittest_params *ut_params,
14062                 const struct test_crypto_vector *reference)
14063 {
14064         int retval;
14065
14066         uint8_t *ciphertext;
14067         uint8_t cipher_key[reference->cipher_key.len + 1];
14068         uint8_t auth_key[reference->auth_key.len + 1];
14069         struct rte_cryptodev_info dev_info;
14070
14071         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14072         uint64_t feat_flags = dev_info.feature_flags;
14073
14074         if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14075                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14076                 printf("Device doesn't support RAW data-path APIs.\n");
14077                 return TEST_SKIPPED;
14078         }
14079
14080         /* Verify the capabilities */
14081         struct rte_cryptodev_sym_capability_idx cap_idx;
14082         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14083         cap_idx.algo.auth = reference->auth_algo;
14084         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14085                         &cap_idx) == NULL)
14086                 return TEST_SKIPPED;
14087         cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14088         cap_idx.algo.cipher = reference->crypto_algo;
14089         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14090                         &cap_idx) == NULL)
14091                 return TEST_SKIPPED;
14092
14093         /* Create session */
14094         memcpy(cipher_key, reference->cipher_key.data,
14095                         reference->cipher_key.len);
14096         memcpy(auth_key, reference->auth_key.data, reference->auth_key.len);
14097
14098         /* Setup Authentication Parameters */
14099         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
14100         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
14101         ut_params->auth_xform.auth.algo = reference->auth_algo;
14102         ut_params->auth_xform.auth.key.length = reference->auth_key.len;
14103         ut_params->auth_xform.auth.key.data = auth_key;
14104         ut_params->auth_xform.auth.digest_length = reference->digest.len;
14105         ut_params->auth_xform.next = &ut_params->cipher_xform;
14106
14107         /* Setup Cipher Parameters */
14108         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
14109         ut_params->cipher_xform.next = NULL;
14110         ut_params->cipher_xform.cipher.algo = reference->crypto_algo;
14111         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
14112         ut_params->cipher_xform.cipher.key.data = cipher_key;
14113         ut_params->cipher_xform.cipher.key.length = reference->cipher_key.len;
14114         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
14115         ut_params->cipher_xform.cipher.iv.length = reference->iv.len;
14116
14117         /* Create Crypto session*/
14118         ut_params->sess = rte_cryptodev_sym_session_create(
14119                         ts_params->session_mpool);
14120         TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
14121
14122         retval = rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
14123                                 ut_params->sess,
14124                                 &ut_params->auth_xform,
14125                                 ts_params->session_priv_mpool);
14126
14127         if (retval == -ENOTSUP)
14128                 return TEST_SKIPPED;
14129
14130         TEST_ASSERT_EQUAL(retval, 0, "Session init failed");
14131
14132         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14133         TEST_ASSERT_NOT_NULL(ut_params->ibuf,
14134                         "Failed to allocate input buffer in mempool");
14135
14136         /* clear mbuf payload */
14137         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14138                         rte_pktmbuf_tailroom(ut_params->ibuf));
14139
14140         ciphertext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14141                         reference->ciphertext.len);
14142         TEST_ASSERT_NOT_NULL(ciphertext, "no room to append ciphertext");
14143         memcpy(ciphertext, reference->ciphertext.data,
14144                         reference->ciphertext.len);
14145
14146         /* Create operation */
14147         retval = create_cipher_auth_verify_operation(ts_params,
14148                         ut_params,
14149                         reference);
14150
14151         if (retval < 0)
14152                 return retval;
14153
14154         if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14155                 process_cpu_crypt_auth_op(ts_params->valid_devs[0],
14156                         ut_params->op);
14157         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14158                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14159                                 ut_params->op, 1, 1, 0, 0);
14160         else
14161                 ut_params->op = process_crypto_request(ts_params->valid_devs[0],
14162                         ut_params->op);
14163
14164         TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process");
14165         TEST_ASSERT_EQUAL(ut_params->op->status,
14166                         RTE_CRYPTO_OP_STATUS_SUCCESS,
14167                         "crypto op processing passed");
14168
14169         ut_params->obuf = ut_params->op->sym->m_src;
14170         TEST_ASSERT_NOT_NULL(ut_params->obuf, "failed to retrieve obuf");
14171
14172         return 0;
14173 }
14174
14175 static int
14176 create_aead_operation_SGL(enum rte_crypto_aead_operation op,
14177                 const struct aead_test_data *tdata,
14178                 void *digest_mem, uint64_t digest_phys)
14179 {
14180         struct crypto_testsuite_params *ts_params = &testsuite_params;
14181         struct crypto_unittest_params *ut_params = &unittest_params;
14182
14183         const unsigned int auth_tag_len = tdata->auth_tag.len;
14184         const unsigned int iv_len = tdata->iv.len;
14185         unsigned int aad_len = tdata->aad.len;
14186         unsigned int aad_len_pad = 0;
14187
14188         /* Generate Crypto op data structure */
14189         ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool,
14190                         RTE_CRYPTO_OP_TYPE_SYMMETRIC);
14191         TEST_ASSERT_NOT_NULL(ut_params->op,
14192                 "Failed to allocate symmetric crypto operation struct");
14193
14194         struct rte_crypto_sym_op *sym_op = ut_params->op->sym;
14195
14196         sym_op->aead.digest.data = digest_mem;
14197
14198         TEST_ASSERT_NOT_NULL(sym_op->aead.digest.data,
14199                         "no room to append digest");
14200
14201         sym_op->aead.digest.phys_addr = digest_phys;
14202
14203         if (op == RTE_CRYPTO_AEAD_OP_DECRYPT) {
14204                 rte_memcpy(sym_op->aead.digest.data, tdata->auth_tag.data,
14205                                 auth_tag_len);
14206                 debug_hexdump(stdout, "digest:",
14207                                 sym_op->aead.digest.data,
14208                                 auth_tag_len);
14209         }
14210
14211         /* Append aad data */
14212         if (tdata->algo == RTE_CRYPTO_AEAD_AES_CCM) {
14213                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14214                                 uint8_t *, IV_OFFSET);
14215
14216                 /* Copy IV 1 byte after the IV pointer, according to the API */
14217                 rte_memcpy(iv_ptr + 1, tdata->iv.data, iv_len);
14218
14219                 aad_len = RTE_ALIGN_CEIL(aad_len + 18, 16);
14220
14221                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14222                                 ut_params->ibuf, aad_len);
14223                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14224                                 "no room to prepend aad");
14225                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14226                                 ut_params->ibuf);
14227
14228                 memset(sym_op->aead.aad.data, 0, aad_len);
14229                 /* Copy AAD 18 bytes after the AAD pointer, according to the API */
14230                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14231
14232                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14233                 debug_hexdump(stdout, "aad:",
14234                                 sym_op->aead.aad.data, aad_len);
14235         } else {
14236                 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op,
14237                                 uint8_t *, IV_OFFSET);
14238
14239                 rte_memcpy(iv_ptr, tdata->iv.data, iv_len);
14240
14241                 aad_len_pad = RTE_ALIGN_CEIL(aad_len, 16);
14242
14243                 sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_prepend(
14244                                 ut_params->ibuf, aad_len_pad);
14245                 TEST_ASSERT_NOT_NULL(sym_op->aead.aad.data,
14246                                 "no room to prepend aad");
14247                 sym_op->aead.aad.phys_addr = rte_pktmbuf_iova(
14248                                 ut_params->ibuf);
14249
14250                 memset(sym_op->aead.aad.data, 0, aad_len);
14251                 rte_memcpy(sym_op->aead.aad.data, tdata->aad.data, aad_len);
14252
14253                 debug_hexdump(stdout, "iv:", iv_ptr, iv_len);
14254                 debug_hexdump(stdout, "aad:",
14255                                 sym_op->aead.aad.data, aad_len);
14256         }
14257
14258         sym_op->aead.data.length = tdata->plaintext.len;
14259         sym_op->aead.data.offset = aad_len_pad;
14260
14261         return 0;
14262 }
14263
14264 #define SGL_MAX_NO      16
14265
14266 static int
14267 test_authenticated_encryption_SGL(const struct aead_test_data *tdata,
14268                 const int oop, uint32_t fragsz, uint32_t fragsz_oop)
14269 {
14270         struct crypto_testsuite_params *ts_params = &testsuite_params;
14271         struct crypto_unittest_params *ut_params = &unittest_params;
14272         struct rte_mbuf *buf, *buf_oop = NULL, *buf_last_oop = NULL;
14273         int retval;
14274         int to_trn = 0;
14275         int to_trn_tbl[SGL_MAX_NO];
14276         int segs = 1;
14277         unsigned int trn_data = 0;
14278         uint8_t *plaintext, *ciphertext, *auth_tag;
14279         struct rte_cryptodev_info dev_info;
14280
14281         /* Verify the capabilities */
14282         struct rte_cryptodev_sym_capability_idx cap_idx;
14283         cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
14284         cap_idx.algo.aead = tdata->algo;
14285         if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
14286                         &cap_idx) == NULL)
14287                 return TEST_SKIPPED;
14288
14289         /* OOP not supported with CPU crypto */
14290         if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14291                 return TEST_SKIPPED;
14292
14293         /* Detailed check for the particular SGL support flag */
14294         rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
14295         if (!oop) {
14296                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14297                 if (sgl_in && (!(dev_info.feature_flags &
14298                                 RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
14299                         return TEST_SKIPPED;
14300
14301                 uint64_t feat_flags = dev_info.feature_flags;
14302
14303                 if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
14304                         (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
14305                         printf("Device doesn't support RAW data-path APIs.\n");
14306                         return TEST_SKIPPED;
14307                 }
14308         } else {
14309                 unsigned int sgl_in = fragsz < tdata->plaintext.len;
14310                 unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) <
14311                                 tdata->plaintext.len;
14312                 /* Raw data path API does not support OOP */
14313                 if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14314                         return TEST_SKIPPED;
14315                 if (sgl_in && !sgl_out) {
14316                         if (!(dev_info.feature_flags &
14317                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
14318                                 return TEST_SKIPPED;
14319                 } else if (!sgl_in && sgl_out) {
14320                         if (!(dev_info.feature_flags &
14321                                         RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
14322                                 return TEST_SKIPPED;
14323                 } else if (sgl_in && sgl_out) {
14324                         if (!(dev_info.feature_flags &
14325                                         RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
14326                                 return TEST_SKIPPED;
14327                 }
14328         }
14329
14330         if (fragsz > tdata->plaintext.len)
14331                 fragsz = tdata->plaintext.len;
14332
14333         uint16_t plaintext_len = fragsz;
14334         uint16_t frag_size_oop = fragsz_oop ? fragsz_oop : fragsz;
14335
14336         if (fragsz_oop > tdata->plaintext.len)
14337                 frag_size_oop = tdata->plaintext.len;
14338
14339         int ecx = 0;
14340         void *digest_mem = NULL;
14341
14342         uint32_t prepend_len = RTE_ALIGN_CEIL(tdata->aad.len, 16);
14343
14344         if (tdata->plaintext.len % fragsz != 0) {
14345                 if (tdata->plaintext.len / fragsz + 1 > SGL_MAX_NO)
14346                         return 1;
14347         }       else {
14348                 if (tdata->plaintext.len / fragsz > SGL_MAX_NO)
14349                         return 1;
14350         }
14351
14352         /*
14353          * For out-op-place we need to alloc another mbuf
14354          */
14355         if (oop) {
14356                 ut_params->obuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14357                 rte_pktmbuf_append(ut_params->obuf,
14358                                 frag_size_oop + prepend_len);
14359                 buf_oop = ut_params->obuf;
14360         }
14361
14362         /* Create AEAD session */
14363         retval = create_aead_session(ts_params->valid_devs[0],
14364                         tdata->algo,
14365                         RTE_CRYPTO_AEAD_OP_ENCRYPT,
14366                         tdata->key.data, tdata->key.len,
14367                         tdata->aad.len, tdata->auth_tag.len,
14368                         tdata->iv.len);
14369         if (retval < 0)
14370                 return retval;
14371
14372         ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14373
14374         /* clear mbuf payload */
14375         memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0,
14376                         rte_pktmbuf_tailroom(ut_params->ibuf));
14377
14378         plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14379                         plaintext_len);
14380
14381         memcpy(plaintext, tdata->plaintext.data, plaintext_len);
14382
14383         trn_data += plaintext_len;
14384
14385         buf = ut_params->ibuf;
14386
14387         /*
14388          * Loop until no more fragments
14389          */
14390
14391         while (trn_data < tdata->plaintext.len) {
14392                 ++segs;
14393                 to_trn = (tdata->plaintext.len - trn_data < fragsz) ?
14394                                 (tdata->plaintext.len - trn_data) : fragsz;
14395
14396                 to_trn_tbl[ecx++] = to_trn;
14397
14398                 buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool);
14399                 buf = buf->next;
14400
14401                 memset(rte_pktmbuf_mtod(buf, uint8_t *), 0,
14402                                 rte_pktmbuf_tailroom(buf));
14403
14404                 /* OOP */
14405                 if (oop && !fragsz_oop) {
14406                         buf_last_oop = buf_oop->next =
14407                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14408                         buf_oop = buf_oop->next;
14409                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14410                                         0, rte_pktmbuf_tailroom(buf_oop));
14411                         rte_pktmbuf_append(buf_oop, to_trn);
14412                 }
14413
14414                 plaintext = (uint8_t *)rte_pktmbuf_append(buf,
14415                                 to_trn);
14416
14417                 memcpy(plaintext, tdata->plaintext.data + trn_data,
14418                                 to_trn);
14419                 trn_data += to_trn;
14420                 if (trn_data  == tdata->plaintext.len) {
14421                         if (oop) {
14422                                 if (!fragsz_oop)
14423                                         digest_mem = rte_pktmbuf_append(buf_oop,
14424                                                 tdata->auth_tag.len);
14425                         } else
14426                                 digest_mem = (uint8_t *)rte_pktmbuf_append(buf,
14427                                         tdata->auth_tag.len);
14428                 }
14429         }
14430
14431         uint64_t digest_phys = 0;
14432
14433         ut_params->ibuf->nb_segs = segs;
14434
14435         segs = 1;
14436         if (fragsz_oop && oop) {
14437                 to_trn = 0;
14438                 ecx = 0;
14439
14440                 if (frag_size_oop == tdata->plaintext.len) {
14441                         digest_mem = rte_pktmbuf_append(ut_params->obuf,
14442                                 tdata->auth_tag.len);
14443
14444                         digest_phys = rte_pktmbuf_iova_offset(
14445                                         ut_params->obuf,
14446                                         tdata->plaintext.len + prepend_len);
14447                 }
14448
14449                 trn_data = frag_size_oop;
14450                 while (trn_data < tdata->plaintext.len) {
14451                         ++segs;
14452                         to_trn =
14453                                 (tdata->plaintext.len - trn_data <
14454                                                 frag_size_oop) ?
14455                                 (tdata->plaintext.len - trn_data) :
14456                                                 frag_size_oop;
14457
14458                         to_trn_tbl[ecx++] = to_trn;
14459
14460                         buf_last_oop = buf_oop->next =
14461                                         rte_pktmbuf_alloc(ts_params->mbuf_pool);
14462                         buf_oop = buf_oop->next;
14463                         memset(rte_pktmbuf_mtod(buf_oop, uint8_t *),
14464                                         0, rte_pktmbuf_tailroom(buf_oop));
14465                         rte_pktmbuf_append(buf_oop, to_trn);
14466
14467                         trn_data += to_trn;
14468
14469                         if (trn_data  == tdata->plaintext.len) {
14470                                 digest_mem = rte_pktmbuf_append(buf_oop,
14471                                         tdata->auth_tag.len);
14472                         }
14473                 }
14474
14475                 ut_params->obuf->nb_segs = segs;
14476         }
14477
14478         /*
14479          * Place digest at the end of the last buffer
14480          */
14481         if (!digest_phys)
14482                 digest_phys = rte_pktmbuf_iova(buf) + to_trn;
14483         if (oop && buf_last_oop)
14484                 digest_phys = rte_pktmbuf_iova(buf_last_oop) + to_trn;
14485
14486         if (!digest_mem && !oop) {
14487                 digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf,
14488                                 + tdata->auth_tag.len);
14489                 digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf,
14490                                 tdata->plaintext.len);
14491         }
14492
14493         /* Create AEAD operation */
14494         retval = create_aead_operation_SGL(RTE_CRYPTO_AEAD_OP_ENCRYPT,
14495                         tdata, digest_mem, digest_phys);
14496
14497         if (retval < 0)
14498                 return retval;
14499
14500         rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess);
14501
14502         ut_params->op->sym->m_src = ut_params->ibuf;
14503         if (oop)
14504                 ut_params->op->sym->m_dst = ut_params->obuf;
14505
14506         /* Process crypto operation */
14507         if (oop == IN_PLACE &&
14508                         gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
14509                 process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op);
14510         else if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
14511                 process_sym_raw_dp_op(ts_params->valid_devs[0], 0,
14512                                 ut_params->op, 0, 0, 0, 0);
14513         else
14514                 TEST_ASSERT_NOT_NULL(
14515                         process_crypto_request(ts_params->valid_devs[0],
14516                         ut_params->op), "failed to process sym crypto op");
14517
14518         TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS,
14519                         "crypto op processing failed");
14520
14521
14522         ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_src,
14523                         uint8_t *, prepend_len);
14524         if (oop) {
14525                 ciphertext = rte_pktmbuf_mtod_offset(ut_params->op->sym->m_dst,
14526                                 uint8_t *, prepend_len);
14527         }
14528
14529         if (fragsz_oop)
14530                 fragsz = fragsz_oop;
14531
14532         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14533                         ciphertext,
14534                         tdata->ciphertext.data,
14535                         fragsz,
14536                         "Ciphertext data not as expected");
14537
14538         buf = ut_params->op->sym->m_src->next;
14539         if (oop)
14540                 buf = ut_params->op->sym->m_dst->next;
14541
14542         unsigned int off = fragsz;
14543
14544         ecx = 0;
14545         while (buf) {
14546                 ciphertext = rte_pktmbuf_mtod(buf,
14547                                 uint8_t *);
14548
14549                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
14550                                 ciphertext,
14551                                 tdata->ciphertext.data + off,
14552                                 to_trn_tbl[ecx],
14553                                 "Ciphertext data not as expected");
14554
14555                 off += to_trn_tbl[ecx++];
14556                 buf = buf->next;
14557         }
14558
14559         auth_tag = digest_mem;
14560         TEST_ASSERT_BUFFERS_ARE_EQUAL(
14561                         auth_tag,
14562                         tdata->auth_tag.data,
14563                         tdata->auth_tag.len,
14564                         "Generated auth tag not as expected");
14565
14566         return 0;
14567 }
14568
14569 static int
14570 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B(void)
14571 {
14572         return test_authenticated_encryption_SGL(
14573                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 400, 400);
14574 }
14575
14576 static int
14577 test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B(void)
14578 {
14579         return test_authenticated_encryption_SGL(
14580                         &gcm_test_case_SGL_1, OUT_OF_PLACE, 1500, 2000);
14581 }
14582
14583 static int
14584 test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg(void)
14585 {
14586         return test_authenticated_encryption_SGL(
14587                         &gcm_test_case_8, OUT_OF_PLACE, 400,
14588                         gcm_test_case_8.plaintext.len);
14589 }
14590
14591 static int
14592 test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void)
14593 {
14594         /* This test is not for OPENSSL PMD */
14595         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14596                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
14597                 return TEST_SKIPPED;
14598
14599         return test_authenticated_encryption_SGL(
14600                         &gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
14601 }
14602
14603 static int
14604 test_authentication_verify_fail_when_data_corrupted(
14605                 struct crypto_testsuite_params *ts_params,
14606                 struct crypto_unittest_params *ut_params,
14607                 const struct test_crypto_vector *reference)
14608 {
14609         return test_authentication_verify_fail_when_data_corruption(
14610                         ts_params, ut_params, reference, 1);
14611 }
14612
14613 static int
14614 test_authentication_verify_fail_when_tag_corrupted(
14615                 struct crypto_testsuite_params *ts_params,
14616                 struct crypto_unittest_params *ut_params,
14617                 const struct test_crypto_vector *reference)
14618 {
14619         return test_authentication_verify_fail_when_data_corruption(
14620                         ts_params, ut_params, reference, 0);
14621 }
14622
14623 static int
14624 test_authentication_verify_GMAC_fail_when_data_corrupted(
14625                 struct crypto_testsuite_params *ts_params,
14626                 struct crypto_unittest_params *ut_params,
14627                 const struct test_crypto_vector *reference)
14628 {
14629         return test_authentication_verify_GMAC_fail_when_corruption(
14630                         ts_params, ut_params, reference, 1);
14631 }
14632
14633 static int
14634 test_authentication_verify_GMAC_fail_when_tag_corrupted(
14635                 struct crypto_testsuite_params *ts_params,
14636                 struct crypto_unittest_params *ut_params,
14637                 const struct test_crypto_vector *reference)
14638 {
14639         return test_authentication_verify_GMAC_fail_when_corruption(
14640                         ts_params, ut_params, reference, 0);
14641 }
14642
14643 static int
14644 test_authenticated_decryption_fail_when_data_corrupted(
14645                 struct crypto_testsuite_params *ts_params,
14646                 struct crypto_unittest_params *ut_params,
14647                 const struct test_crypto_vector *reference)
14648 {
14649         return test_authenticated_decryption_fail_when_corruption(
14650                         ts_params, ut_params, reference, 1);
14651 }
14652
14653 static int
14654 test_authenticated_decryption_fail_when_tag_corrupted(
14655                 struct crypto_testsuite_params *ts_params,
14656                 struct crypto_unittest_params *ut_params,
14657                 const struct test_crypto_vector *reference)
14658 {
14659         return test_authenticated_decryption_fail_when_corruption(
14660                         ts_params, ut_params, reference, 0);
14661 }
14662
14663 static int
14664 authentication_verify_HMAC_SHA1_fail_data_corrupt(void)
14665 {
14666         return test_authentication_verify_fail_when_data_corrupted(
14667                         &testsuite_params, &unittest_params,
14668                         &hmac_sha1_test_crypto_vector);
14669 }
14670
14671 static int
14672 authentication_verify_HMAC_SHA1_fail_tag_corrupt(void)
14673 {
14674         return test_authentication_verify_fail_when_tag_corrupted(
14675                         &testsuite_params, &unittest_params,
14676                         &hmac_sha1_test_crypto_vector);
14677 }
14678
14679 static int
14680 authentication_verify_AES128_GMAC_fail_data_corrupt(void)
14681 {
14682         return test_authentication_verify_GMAC_fail_when_data_corrupted(
14683                         &testsuite_params, &unittest_params,
14684                         &aes128_gmac_test_vector);
14685 }
14686
14687 static int
14688 authentication_verify_AES128_GMAC_fail_tag_corrupt(void)
14689 {
14690         return test_authentication_verify_GMAC_fail_when_tag_corrupted(
14691                         &testsuite_params, &unittest_params,
14692                         &aes128_gmac_test_vector);
14693 }
14694
14695 static int
14696 auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt(void)
14697 {
14698         return test_authenticated_decryption_fail_when_data_corrupted(
14699                         &testsuite_params,
14700                         &unittest_params,
14701                         &aes128cbc_hmac_sha1_test_vector);
14702 }
14703
14704 static int
14705 auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void)
14706 {
14707         return test_authenticated_decryption_fail_when_tag_corrupted(
14708                         &testsuite_params,
14709                         &unittest_params,
14710                         &aes128cbc_hmac_sha1_test_vector);
14711 }
14712
14713 static int
14714 auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14715 {
14716         return test_authenticated_encrypt_with_esn(
14717                         &testsuite_params,
14718                         &unittest_params,
14719                         &aes128cbc_hmac_sha1_aad_test_vector);
14720 }
14721
14722 static int
14723 auth_decrypt_AES128CBC_HMAC_SHA1_esn_check(void)
14724 {
14725         return test_authenticated_decrypt_with_esn(
14726                         &testsuite_params,
14727                         &unittest_params,
14728                         &aes128cbc_hmac_sha1_aad_test_vector);
14729 }
14730
14731 static int
14732 test_chacha20_poly1305_encrypt_test_case_rfc8439(void)
14733 {
14734         return test_authenticated_encryption(&chacha20_poly1305_case_rfc8439);
14735 }
14736
14737 static int
14738 test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
14739 {
14740         return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
14741 }
14742
14743 static int
14744 test_chacha20_poly1305_encrypt_SGL_out_of_place(void)
14745 {
14746         return test_authenticated_encryption_SGL(
14747                 &chacha20_poly1305_case_2, OUT_OF_PLACE, 32,
14748                 chacha20_poly1305_case_2.plaintext.len);
14749 }
14750
14751 #ifdef RTE_CRYPTO_SCHEDULER
14752
14753 /* global AESNI worker IDs for the scheduler test */
14754 uint8_t aesni_ids[2];
14755
14756 static int
14757 scheduler_testsuite_setup(void)
14758 {
14759         uint32_t i = 0;
14760         int32_t nb_devs, ret;
14761         char vdev_args[VDEV_ARGS_SIZE] = {""};
14762         char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
14763                 "ordering=enable,name=cryptodev_test_scheduler,corelist="};
14764         uint16_t worker_core_count = 0;
14765         uint16_t socket_id = 0;
14766
14767         if (gbl_driver_id == rte_cryptodev_driver_id_get(
14768                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
14769
14770                 /* Identify the Worker Cores
14771                  * Use 2 worker cores for the device args
14772                  */
14773                 RTE_LCORE_FOREACH_WORKER(i) {
14774                         if (worker_core_count > 1)
14775                                 break;
14776                         snprintf(vdev_args, sizeof(vdev_args),
14777                                         "%s%d", temp_str, i);
14778                         strcpy(temp_str, vdev_args);
14779                         strlcat(temp_str, ";", sizeof(temp_str));
14780                         worker_core_count++;
14781                         socket_id = rte_lcore_to_socket_id(i);
14782                 }
14783                 if (worker_core_count != 2) {
14784                         RTE_LOG(ERR, USER1,
14785                                 "Cryptodev scheduler test require at least "
14786                                 "two worker cores to run. "
14787                                 "Please use the correct coremask.\n");
14788                         return TEST_FAILED;
14789                 }
14790                 strcpy(temp_str, vdev_args);
14791                 snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
14792                                 temp_str, socket_id);
14793                 RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
14794                 nb_devs = rte_cryptodev_device_count_by_driver(
14795                                 rte_cryptodev_driver_id_get(
14796                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
14797                 if (nb_devs < 1) {
14798                         ret = rte_vdev_init(
14799                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
14800                                         vdev_args);
14801                         TEST_ASSERT(ret == 0,
14802                                 "Failed to create instance %u of pmd : %s",
14803                                 i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
14804                 }
14805         }
14806         return testsuite_setup();
14807 }
14808
14809 static int
14810 test_scheduler_attach_worker_op(void)
14811 {
14812         struct crypto_testsuite_params *ts_params = &testsuite_params;
14813         uint8_t sched_id = ts_params->valid_devs[0];
14814         uint32_t i, nb_devs_attached = 0;
14815         int ret;
14816         char vdev_name[32];
14817         unsigned int count = rte_cryptodev_count();
14818
14819         /* create 2 AESNI_MB vdevs on top of existing devices */
14820         for (i = count; i < count + 2; i++) {
14821                 snprintf(vdev_name, sizeof(vdev_name), "%s_%u",
14822                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD),
14823                                 i);
14824                 ret = rte_vdev_init(vdev_name, NULL);
14825
14826                 TEST_ASSERT(ret == 0,
14827                         "Failed to create instance %u of"
14828                         " pmd : %s",
14829                         i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14830
14831                 if (ret < 0) {
14832                         RTE_LOG(ERR, USER1,
14833                                 "Failed to create 2 AESNI MB PMDs.\n");
14834                         return TEST_SKIPPED;
14835                 }
14836         }
14837
14838         /* attach 2 AESNI_MB cdevs */
14839         for (i = count; i < count + 2; i++) {
14840                 struct rte_cryptodev_info info;
14841                 unsigned int session_size;
14842
14843                 rte_cryptodev_info_get(i, &info);
14844                 if (info.driver_id != rte_cryptodev_driver_id_get(
14845                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
14846                         continue;
14847
14848                 session_size = rte_cryptodev_sym_get_private_session_size(i);
14849                 /*
14850                  * Create the session mempool again, since now there are new devices
14851                  * to use the mempool.
14852                  */
14853                 if (ts_params->session_mpool) {
14854                         rte_mempool_free(ts_params->session_mpool);
14855                         ts_params->session_mpool = NULL;
14856                 }
14857                 if (ts_params->session_priv_mpool) {
14858                         rte_mempool_free(ts_params->session_priv_mpool);
14859                         ts_params->session_priv_mpool = NULL;
14860                 }
14861
14862                 if (info.sym.max_nb_sessions != 0 &&
14863                                 info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
14864                         RTE_LOG(ERR, USER1,
14865                                         "Device does not support "
14866                                         "at least %u sessions\n",
14867                                         MAX_NB_SESSIONS);
14868                         return TEST_FAILED;
14869                 }
14870                 /*
14871                  * Create mempool with maximum number of sessions,
14872                  * to include the session headers
14873                  */
14874                 if (ts_params->session_mpool == NULL) {
14875                         ts_params->session_mpool =
14876                                 rte_cryptodev_sym_session_pool_create(
14877                                                 "test_sess_mp",
14878                                                 MAX_NB_SESSIONS, 0, 0, 0,
14879                                                 SOCKET_ID_ANY);
14880                         TEST_ASSERT_NOT_NULL(ts_params->session_mpool,
14881                                         "session mempool allocation failed");
14882                 }
14883
14884                 /*
14885                  * Create mempool with maximum number of sessions,
14886                  * to include device specific session private data
14887                  */
14888                 if (ts_params->session_priv_mpool == NULL) {
14889                         ts_params->session_priv_mpool = rte_mempool_create(
14890                                         "test_sess_mp_priv",
14891                                         MAX_NB_SESSIONS,
14892                                         session_size,
14893                                         0, 0, NULL, NULL, NULL,
14894                                         NULL, SOCKET_ID_ANY,
14895                                         0);
14896
14897                         TEST_ASSERT_NOT_NULL(ts_params->session_priv_mpool,
14898                                         "session mempool allocation failed");
14899                 }
14900
14901                 ts_params->qp_conf.mp_session = ts_params->session_mpool;
14902                 ts_params->qp_conf.mp_session_private =
14903                                 ts_params->session_priv_mpool;
14904
14905                 ret = rte_cryptodev_scheduler_worker_attach(sched_id,
14906                                 (uint8_t)i);
14907
14908                 TEST_ASSERT(ret == 0,
14909                         "Failed to attach device %u of pmd : %s", i,
14910                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
14911
14912                 aesni_ids[nb_devs_attached] = (uint8_t)i;
14913
14914                 nb_devs_attached++;
14915         }
14916
14917         return 0;
14918 }
14919
14920 static int
14921 test_scheduler_detach_worker_op(void)
14922 {
14923         struct crypto_testsuite_params *ts_params = &testsuite_params;
14924         uint8_t sched_id = ts_params->valid_devs[0];
14925         uint32_t i;
14926         int ret;
14927
14928         for (i = 0; i < 2; i++) {
14929                 ret = rte_cryptodev_scheduler_worker_detach(sched_id,
14930                                 aesni_ids[i]);
14931                 TEST_ASSERT(ret == 0,
14932                         "Failed to detach device %u", aesni_ids[i]);
14933         }
14934
14935         return 0;
14936 }
14937
14938 static int
14939 test_scheduler_mode_op(enum rte_cryptodev_scheduler_mode scheduler_mode)
14940 {
14941         struct crypto_testsuite_params *ts_params = &testsuite_params;
14942         uint8_t sched_id = ts_params->valid_devs[0];
14943         /* set mode */
14944         return rte_cryptodev_scheduler_mode_set(sched_id,
14945                 scheduler_mode);
14946 }
14947
14948 static int
14949 test_scheduler_mode_roundrobin_op(void)
14950 {
14951         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) ==
14952                         0, "Failed to set roundrobin mode");
14953         return 0;
14954
14955 }
14956
14957 static int
14958 test_scheduler_mode_multicore_op(void)
14959 {
14960         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) ==
14961                         0, "Failed to set multicore mode");
14962
14963         return 0;
14964 }
14965
14966 static int
14967 test_scheduler_mode_failover_op(void)
14968 {
14969         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) ==
14970                         0, "Failed to set failover mode");
14971
14972         return 0;
14973 }
14974
14975 static int
14976 test_scheduler_mode_pkt_size_distr_op(void)
14977 {
14978         TEST_ASSERT(test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) ==
14979                         0, "Failed to set pktsize mode");
14980
14981         return 0;
14982 }
14983
14984 static int
14985 scheduler_multicore_testsuite_setup(void)
14986 {
14987         if (test_scheduler_attach_worker_op() < 0)
14988                 return TEST_SKIPPED;
14989         if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
14990                 return TEST_SKIPPED;
14991         return 0;
14992 }
14993
14994 static int
14995 scheduler_roundrobin_testsuite_setup(void)
14996 {
14997         if (test_scheduler_attach_worker_op() < 0)
14998                 return TEST_SKIPPED;
14999         if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
15000                 return TEST_SKIPPED;
15001         return 0;
15002 }
15003
15004 static int
15005 scheduler_failover_testsuite_setup(void)
15006 {
15007         if (test_scheduler_attach_worker_op() < 0)
15008                 return TEST_SKIPPED;
15009         if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
15010                 return TEST_SKIPPED;
15011         return 0;
15012 }
15013
15014 static int
15015 scheduler_pkt_size_distr_testsuite_setup(void)
15016 {
15017         if (test_scheduler_attach_worker_op() < 0)
15018                 return TEST_SKIPPED;
15019         if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
15020                 return TEST_SKIPPED;
15021         return 0;
15022 }
15023
15024 static void
15025 scheduler_mode_testsuite_teardown(void)
15026 {
15027         test_scheduler_detach_worker_op();
15028 }
15029
15030 #endif /* RTE_CRYPTO_SCHEDULER */
15031
15032 static struct unit_test_suite end_testsuite = {
15033         .suite_name = NULL,
15034         .setup = NULL,
15035         .teardown = NULL,
15036         .unit_test_suites = NULL
15037 };
15038
15039 #ifdef RTE_LIB_SECURITY
15040 static struct unit_test_suite ipsec_proto_testsuite  = {
15041         .suite_name = "IPsec Proto Unit Test Suite",
15042         .setup = ipsec_proto_testsuite_setup,
15043         .unit_test_cases = {
15044                 TEST_CASE_NAMED_WITH_DATA(
15045                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15046                         ut_setup_security, ut_teardown,
15047                         test_ipsec_proto_known_vec, &pkt_aes_128_gcm),
15048                 TEST_CASE_NAMED_WITH_DATA(
15049                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15050                         ut_setup_security, ut_teardown,
15051                         test_ipsec_proto_known_vec, &pkt_aes_192_gcm),
15052                 TEST_CASE_NAMED_WITH_DATA(
15053                         "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15054                         ut_setup_security, ut_teardown,
15055                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm),
15056                 TEST_CASE_NAMED_WITH_DATA(
15057                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15058                         ut_setup_security, ut_teardown,
15059                         test_ipsec_proto_known_vec,
15060                         &pkt_aes_128_cbc_hmac_sha256),
15061                 TEST_CASE_NAMED_WITH_DATA(
15062                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15063                         ut_setup_security, ut_teardown,
15064                         test_ipsec_proto_known_vec,
15065                         &pkt_aes_128_cbc_hmac_sha384),
15066                 TEST_CASE_NAMED_WITH_DATA(
15067                         "Outbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15068                         ut_setup_security, ut_teardown,
15069                         test_ipsec_proto_known_vec,
15070                         &pkt_aes_128_cbc_hmac_sha512),
15071                 TEST_CASE_NAMED_WITH_DATA(
15072                         "Outbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15073                         ut_setup_security, ut_teardown,
15074                         test_ipsec_proto_known_vec, &pkt_aes_256_gcm_v6),
15075                 TEST_CASE_NAMED_WITH_DATA(
15076                         "Outbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15077                         ut_setup_security, ut_teardown,
15078                         test_ipsec_proto_known_vec,
15079                         &pkt_aes_128_cbc_hmac_sha256_v6),
15080                 TEST_CASE_NAMED_WITH_DATA(
15081                         "Outbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15082                         ut_setup_security, ut_teardown,
15083                         test_ipsec_proto_known_vec,
15084                         &pkt_null_aes_xcbc),
15085                 TEST_CASE_NAMED_WITH_DATA(
15086                         "Outbound fragmented packet",
15087                         ut_setup_security, ut_teardown,
15088                         test_ipsec_proto_known_vec_fragmented,
15089                         &pkt_aes_128_gcm_frag),
15090                 TEST_CASE_NAMED_WITH_DATA(
15091                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)",
15092                         ut_setup_security, ut_teardown,
15093                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm),
15094                 TEST_CASE_NAMED_WITH_DATA(
15095                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)",
15096                         ut_setup_security, ut_teardown,
15097                         test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm),
15098                 TEST_CASE_NAMED_WITH_DATA(
15099                         "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)",
15100                         ut_setup_security, ut_teardown,
15101                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm),
15102                 TEST_CASE_NAMED_WITH_DATA(
15103                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128)",
15104                         ut_setup_security, ut_teardown,
15105                         test_ipsec_proto_known_vec_inb, &pkt_aes_128_cbc_null),
15106                 TEST_CASE_NAMED_WITH_DATA(
15107                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15108                         ut_setup_security, ut_teardown,
15109                         test_ipsec_proto_known_vec_inb,
15110                         &pkt_aes_128_cbc_hmac_sha256),
15111                 TEST_CASE_NAMED_WITH_DATA(
15112                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA384 [24B ICV])",
15113                         ut_setup_security, ut_teardown,
15114                         test_ipsec_proto_known_vec_inb,
15115                         &pkt_aes_128_cbc_hmac_sha384),
15116                 TEST_CASE_NAMED_WITH_DATA(
15117                         "Inbound known vector (ESP tunnel mode IPv4 AES-CBC 128 HMAC-SHA512 [32B ICV])",
15118                         ut_setup_security, ut_teardown,
15119                         test_ipsec_proto_known_vec_inb,
15120                         &pkt_aes_128_cbc_hmac_sha512),
15121                 TEST_CASE_NAMED_WITH_DATA(
15122                         "Inbound known vector (ESP tunnel mode IPv6 AES-GCM 128)",
15123                         ut_setup_security, ut_teardown,
15124                         test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm_v6),
15125                 TEST_CASE_NAMED_WITH_DATA(
15126                         "Inbound known vector (ESP tunnel mode IPv6 AES-CBC 128 HMAC-SHA256 [16B ICV])",
15127                         ut_setup_security, ut_teardown,
15128                         test_ipsec_proto_known_vec_inb,
15129                         &pkt_aes_128_cbc_hmac_sha256_v6),
15130                 TEST_CASE_NAMED_WITH_DATA(
15131                         "Inbound known vector (ESP tunnel mode IPv4 NULL AES-XCBC-MAC [12B ICV])",
15132                         ut_setup_security, ut_teardown,
15133                         test_ipsec_proto_known_vec_inb,
15134                         &pkt_null_aes_xcbc),
15135                 TEST_CASE_NAMED_ST(
15136                         "Combined test alg list",
15137                         ut_setup_security, ut_teardown,
15138                         test_ipsec_proto_display_list),
15139                 TEST_CASE_NAMED_ST(
15140                         "Combined test alg list (AH)",
15141                         ut_setup_security, ut_teardown,
15142                         test_ipsec_proto_ah_tunnel_ipv4),
15143                 TEST_CASE_NAMED_ST(
15144                         "IV generation",
15145                         ut_setup_security, ut_teardown,
15146                         test_ipsec_proto_iv_gen),
15147                 TEST_CASE_NAMED_ST(
15148                         "UDP encapsulation",
15149                         ut_setup_security, ut_teardown,
15150                         test_ipsec_proto_udp_encap),
15151                 TEST_CASE_NAMED_ST(
15152                         "UDP encapsulation ports verification test",
15153                         ut_setup_security, ut_teardown,
15154                         test_ipsec_proto_udp_ports_verify),
15155                 TEST_CASE_NAMED_ST(
15156                         "SA expiry packets soft",
15157                         ut_setup_security, ut_teardown,
15158                         test_ipsec_proto_sa_exp_pkts_soft),
15159                 TEST_CASE_NAMED_ST(
15160                         "SA expiry packets hard",
15161                         ut_setup_security, ut_teardown,
15162                         test_ipsec_proto_sa_exp_pkts_hard),
15163                 TEST_CASE_NAMED_ST(
15164                         "Negative test: ICV corruption",
15165                         ut_setup_security, ut_teardown,
15166                         test_ipsec_proto_err_icv_corrupt),
15167                 TEST_CASE_NAMED_ST(
15168                         "Tunnel dst addr verification",
15169                         ut_setup_security, ut_teardown,
15170                         test_ipsec_proto_tunnel_dst_addr_verify),
15171                 TEST_CASE_NAMED_ST(
15172                         "Tunnel src and dst addr verification",
15173                         ut_setup_security, ut_teardown,
15174                         test_ipsec_proto_tunnel_src_dst_addr_verify),
15175                 TEST_CASE_NAMED_ST(
15176                         "Inner IP checksum",
15177                         ut_setup_security, ut_teardown,
15178                         test_ipsec_proto_inner_ip_csum),
15179                 TEST_CASE_NAMED_ST(
15180                         "Inner L4 checksum",
15181                         ut_setup_security, ut_teardown,
15182                         test_ipsec_proto_inner_l4_csum),
15183                 TEST_CASE_NAMED_ST(
15184                         "Tunnel IPv4 in IPv4",
15185                         ut_setup_security, ut_teardown,
15186                         test_ipsec_proto_tunnel_v4_in_v4),
15187                 TEST_CASE_NAMED_ST(
15188                         "Tunnel IPv6 in IPv6",
15189                         ut_setup_security, ut_teardown,
15190                         test_ipsec_proto_tunnel_v6_in_v6),
15191                 TEST_CASE_NAMED_ST(
15192                         "Tunnel IPv4 in IPv6",
15193                         ut_setup_security, ut_teardown,
15194                         test_ipsec_proto_tunnel_v4_in_v6),
15195                 TEST_CASE_NAMED_ST(
15196                         "Tunnel IPv6 in IPv4",
15197                         ut_setup_security, ut_teardown,
15198                         test_ipsec_proto_tunnel_v6_in_v4),
15199                 TEST_CASE_NAMED_ST(
15200                         "Transport IPv4",
15201                         ut_setup_security, ut_teardown,
15202                         test_ipsec_proto_transport_v4),
15203                 TEST_CASE_NAMED_ST(
15204                         "AH transport IPv4",
15205                         ut_setup_security, ut_teardown,
15206                         test_ipsec_proto_ah_transport_ipv4),
15207                 TEST_CASE_NAMED_ST(
15208                         "Transport l4 checksum",
15209                         ut_setup_security, ut_teardown,
15210                         test_ipsec_proto_transport_l4_csum),
15211                 TEST_CASE_NAMED_ST(
15212                         "Statistics: success",
15213                         ut_setup_security, ut_teardown,
15214                         test_ipsec_proto_stats),
15215                 TEST_CASE_NAMED_ST(
15216                         "Fragmented packet",
15217                         ut_setup_security, ut_teardown,
15218                         test_ipsec_proto_pkt_fragment),
15219                 TEST_CASE_NAMED_ST(
15220                         "Tunnel header copy DF (inner 0)",
15221                         ut_setup_security, ut_teardown,
15222                         test_ipsec_proto_copy_df_inner_0),
15223                 TEST_CASE_NAMED_ST(
15224                         "Tunnel header copy DF (inner 1)",
15225                         ut_setup_security, ut_teardown,
15226                         test_ipsec_proto_copy_df_inner_1),
15227                 TEST_CASE_NAMED_ST(
15228                         "Tunnel header set DF 0 (inner 1)",
15229                         ut_setup_security, ut_teardown,
15230                         test_ipsec_proto_set_df_0_inner_1),
15231                 TEST_CASE_NAMED_ST(
15232                         "Tunnel header set DF 1 (inner 0)",
15233                         ut_setup_security, ut_teardown,
15234                         test_ipsec_proto_set_df_1_inner_0),
15235                 TEST_CASE_NAMED_ST(
15236                         "Tunnel header IPv4 copy DSCP (inner 0)",
15237                         ut_setup_security, ut_teardown,
15238                         test_ipsec_proto_ipv4_copy_dscp_inner_0),
15239                 TEST_CASE_NAMED_ST(
15240                         "Tunnel header IPv4 copy DSCP (inner 1)",
15241                         ut_setup_security, ut_teardown,
15242                         test_ipsec_proto_ipv4_copy_dscp_inner_1),
15243                 TEST_CASE_NAMED_ST(
15244                         "Tunnel header IPv4 set DSCP 0 (inner 1)",
15245                         ut_setup_security, ut_teardown,
15246                         test_ipsec_proto_ipv4_set_dscp_0_inner_1),
15247                 TEST_CASE_NAMED_ST(
15248                         "Tunnel header IPv4 set DSCP 1 (inner 0)",
15249                         ut_setup_security, ut_teardown,
15250                         test_ipsec_proto_ipv4_set_dscp_1_inner_0),
15251                 TEST_CASE_NAMED_ST(
15252                         "Tunnel header IPv6 copy DSCP (inner 0)",
15253                         ut_setup_security, ut_teardown,
15254                         test_ipsec_proto_ipv6_copy_dscp_inner_0),
15255                 TEST_CASE_NAMED_ST(
15256                         "Tunnel header IPv6 copy DSCP (inner 1)",
15257                         ut_setup_security, ut_teardown,
15258                         test_ipsec_proto_ipv6_copy_dscp_inner_1),
15259                 TEST_CASE_NAMED_ST(
15260                         "Tunnel header IPv6 set DSCP 0 (inner 1)",
15261                         ut_setup_security, ut_teardown,
15262                         test_ipsec_proto_ipv6_set_dscp_0_inner_1),
15263                 TEST_CASE_NAMED_ST(
15264                         "Tunnel header IPv6 set DSCP 1 (inner 0)",
15265                         ut_setup_security, ut_teardown,
15266                         test_ipsec_proto_ipv6_set_dscp_1_inner_0),
15267                 TEST_CASE_NAMED_WITH_DATA(
15268                         "Antireplay with window size 1024",
15269                         ut_setup_security, ut_teardown,
15270                         test_ipsec_proto_pkt_antireplay1024, &pkt_aes_128_gcm),
15271                 TEST_CASE_NAMED_WITH_DATA(
15272                         "Antireplay with window size 2048",
15273                         ut_setup_security, ut_teardown,
15274                         test_ipsec_proto_pkt_antireplay2048, &pkt_aes_128_gcm),
15275                 TEST_CASE_NAMED_WITH_DATA(
15276                         "Antireplay with window size 4096",
15277                         ut_setup_security, ut_teardown,
15278                         test_ipsec_proto_pkt_antireplay4096, &pkt_aes_128_gcm),
15279                 TEST_CASE_NAMED_WITH_DATA(
15280                         "ESN and Antireplay with window size 1024",
15281                         ut_setup_security, ut_teardown,
15282                         test_ipsec_proto_pkt_esn_antireplay1024,
15283                         &pkt_aes_128_gcm),
15284                 TEST_CASE_NAMED_WITH_DATA(
15285                         "ESN and Antireplay with window size 2048",
15286                         ut_setup_security, ut_teardown,
15287                         test_ipsec_proto_pkt_esn_antireplay2048,
15288                         &pkt_aes_128_gcm),
15289                 TEST_CASE_NAMED_WITH_DATA(
15290                         "ESN and Antireplay with window size 4096",
15291                         ut_setup_security, ut_teardown,
15292                         test_ipsec_proto_pkt_esn_antireplay4096,
15293                         &pkt_aes_128_gcm),
15294                 TEST_CASE_NAMED_ST(
15295                         "Tunnel header IPv4 decrement inner TTL",
15296                         ut_setup_security, ut_teardown,
15297                         test_ipsec_proto_ipv4_ttl_decrement),
15298                 TEST_CASE_NAMED_ST(
15299                         "Tunnel header IPv6 decrement inner hop limit",
15300                         ut_setup_security, ut_teardown,
15301                         test_ipsec_proto_ipv6_hop_limit_decrement),
15302                 TEST_CASES_END() /**< NULL terminate unit test array */
15303         }
15304 };
15305
15306 static struct unit_test_suite pdcp_proto_testsuite  = {
15307         .suite_name = "PDCP Proto Unit Test Suite",
15308         .setup = pdcp_proto_testsuite_setup,
15309         .unit_test_cases = {
15310                 TEST_CASE_ST(ut_setup_security, ut_teardown,
15311                         test_PDCP_PROTO_all),
15312                 TEST_CASES_END() /**< NULL terminate unit test array */
15313         }
15314 };
15315
15316 #define ADD_UPLINK_TESTCASE(data)                                               \
15317         TEST_CASE_NAMED_WITH_DATA(data.test_descr_uplink, ut_setup_security,    \
15318         ut_teardown, test_docsis_proto_uplink, (const void *) &data),           \
15319
15320 #define ADD_DOWNLINK_TESTCASE(data)                                             \
15321         TEST_CASE_NAMED_WITH_DATA(data.test_descr_downlink, ut_setup_security,  \
15322         ut_teardown, test_docsis_proto_downlink, (const void *) &data),         \
15323
15324 static struct unit_test_suite docsis_proto_testsuite  = {
15325         .suite_name = "DOCSIS Proto Unit Test Suite",
15326         .setup = docsis_proto_testsuite_setup,
15327         .unit_test_cases = {
15328                 /* Uplink */
15329                 ADD_UPLINK_TESTCASE(docsis_test_case_1)
15330                 ADD_UPLINK_TESTCASE(docsis_test_case_2)
15331                 ADD_UPLINK_TESTCASE(docsis_test_case_3)
15332                 ADD_UPLINK_TESTCASE(docsis_test_case_4)
15333                 ADD_UPLINK_TESTCASE(docsis_test_case_5)
15334                 ADD_UPLINK_TESTCASE(docsis_test_case_6)
15335                 ADD_UPLINK_TESTCASE(docsis_test_case_7)
15336                 ADD_UPLINK_TESTCASE(docsis_test_case_8)
15337                 ADD_UPLINK_TESTCASE(docsis_test_case_9)
15338                 ADD_UPLINK_TESTCASE(docsis_test_case_10)
15339                 ADD_UPLINK_TESTCASE(docsis_test_case_11)
15340                 ADD_UPLINK_TESTCASE(docsis_test_case_12)
15341                 ADD_UPLINK_TESTCASE(docsis_test_case_13)
15342                 ADD_UPLINK_TESTCASE(docsis_test_case_14)
15343                 ADD_UPLINK_TESTCASE(docsis_test_case_15)
15344                 ADD_UPLINK_TESTCASE(docsis_test_case_16)
15345                 ADD_UPLINK_TESTCASE(docsis_test_case_17)
15346                 ADD_UPLINK_TESTCASE(docsis_test_case_18)
15347                 ADD_UPLINK_TESTCASE(docsis_test_case_19)
15348                 ADD_UPLINK_TESTCASE(docsis_test_case_20)
15349                 ADD_UPLINK_TESTCASE(docsis_test_case_21)
15350                 ADD_UPLINK_TESTCASE(docsis_test_case_22)
15351                 ADD_UPLINK_TESTCASE(docsis_test_case_23)
15352                 ADD_UPLINK_TESTCASE(docsis_test_case_24)
15353                 ADD_UPLINK_TESTCASE(docsis_test_case_25)
15354                 ADD_UPLINK_TESTCASE(docsis_test_case_26)
15355                 /* Downlink */
15356                 ADD_DOWNLINK_TESTCASE(docsis_test_case_1)
15357                 ADD_DOWNLINK_TESTCASE(docsis_test_case_2)
15358                 ADD_DOWNLINK_TESTCASE(docsis_test_case_3)
15359                 ADD_DOWNLINK_TESTCASE(docsis_test_case_4)
15360                 ADD_DOWNLINK_TESTCASE(docsis_test_case_5)
15361                 ADD_DOWNLINK_TESTCASE(docsis_test_case_6)
15362                 ADD_DOWNLINK_TESTCASE(docsis_test_case_7)
15363                 ADD_DOWNLINK_TESTCASE(docsis_test_case_8)
15364                 ADD_DOWNLINK_TESTCASE(docsis_test_case_9)
15365                 ADD_DOWNLINK_TESTCASE(docsis_test_case_10)
15366                 ADD_DOWNLINK_TESTCASE(docsis_test_case_11)
15367                 ADD_DOWNLINK_TESTCASE(docsis_test_case_12)
15368                 ADD_DOWNLINK_TESTCASE(docsis_test_case_13)
15369                 ADD_DOWNLINK_TESTCASE(docsis_test_case_14)
15370                 ADD_DOWNLINK_TESTCASE(docsis_test_case_15)
15371                 ADD_DOWNLINK_TESTCASE(docsis_test_case_16)
15372                 ADD_DOWNLINK_TESTCASE(docsis_test_case_17)
15373                 ADD_DOWNLINK_TESTCASE(docsis_test_case_18)
15374                 ADD_DOWNLINK_TESTCASE(docsis_test_case_19)
15375                 ADD_DOWNLINK_TESTCASE(docsis_test_case_20)
15376                 ADD_DOWNLINK_TESTCASE(docsis_test_case_21)
15377                 ADD_DOWNLINK_TESTCASE(docsis_test_case_22)
15378                 ADD_DOWNLINK_TESTCASE(docsis_test_case_23)
15379                 ADD_DOWNLINK_TESTCASE(docsis_test_case_24)
15380                 ADD_DOWNLINK_TESTCASE(docsis_test_case_25)
15381                 ADD_DOWNLINK_TESTCASE(docsis_test_case_26)
15382                 TEST_CASES_END() /**< NULL terminate unit test array */
15383         }
15384 };
15385 #endif
15386
15387 static struct unit_test_suite cryptodev_gen_testsuite  = {
15388         .suite_name = "Crypto General Unit Test Suite",
15389         .setup = crypto_gen_testsuite_setup,
15390         .unit_test_cases = {
15391                 TEST_CASE_ST(ut_setup, ut_teardown,
15392                                 test_device_configure_invalid_dev_id),
15393                 TEST_CASE_ST(ut_setup, ut_teardown,
15394                                 test_queue_pair_descriptor_setup),
15395                 TEST_CASE_ST(ut_setup, ut_teardown,
15396                                 test_device_configure_invalid_queue_pair_ids),
15397                 TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
15398                 TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
15399                 TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
15400                 TEST_CASES_END() /**< NULL terminate unit test array */
15401         }
15402 };
15403
15404 static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
15405         .suite_name = "Negative HMAC SHA1 Unit Test Suite",
15406         .setup = negative_hmac_sha1_testsuite_setup,
15407         .unit_test_cases = {
15408                 /** Negative tests */
15409                 TEST_CASE_ST(ut_setup, ut_teardown,
15410                         authentication_verify_HMAC_SHA1_fail_data_corrupt),
15411                 TEST_CASE_ST(ut_setup, ut_teardown,
15412                         authentication_verify_HMAC_SHA1_fail_tag_corrupt),
15413                 TEST_CASE_ST(ut_setup, ut_teardown,
15414                         auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
15415                 TEST_CASE_ST(ut_setup, ut_teardown,
15416                         auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
15417
15418                 TEST_CASES_END() /**< NULL terminate unit test array */
15419         }
15420 };
15421
15422 static struct unit_test_suite cryptodev_multi_session_testsuite = {
15423         .suite_name = "Multi Session Unit Test Suite",
15424         .setup = multi_session_testsuite_setup,
15425         .unit_test_cases = {
15426                 TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
15427                 TEST_CASE_ST(ut_setup, ut_teardown,
15428                                 test_multi_session_random_usage),
15429
15430                 TEST_CASES_END() /**< NULL terminate unit test array */
15431         }
15432 };
15433
15434 static struct unit_test_suite cryptodev_null_testsuite  = {
15435         .suite_name = "NULL Test Suite",
15436         .setup = null_testsuite_setup,
15437         .unit_test_cases = {
15438                 TEST_CASE_ST(ut_setup, ut_teardown,
15439                         test_null_invalid_operation),
15440                 TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
15441                 TEST_CASES_END()
15442         }
15443 };
15444
15445 static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite  = {
15446         .suite_name = "AES CCM Authenticated Test Suite",
15447         .setup = aes_ccm_auth_testsuite_setup,
15448         .unit_test_cases = {
15449                 /** AES CCM Authenticated Encryption 128 bits key*/
15450                 TEST_CASE_ST(ut_setup, ut_teardown,
15451                         test_AES_CCM_authenticated_encryption_test_case_128_1),
15452                 TEST_CASE_ST(ut_setup, ut_teardown,
15453                         test_AES_CCM_authenticated_encryption_test_case_128_2),
15454                 TEST_CASE_ST(ut_setup, ut_teardown,
15455                         test_AES_CCM_authenticated_encryption_test_case_128_3),
15456
15457                 /** AES CCM Authenticated Decryption 128 bits key*/
15458                 TEST_CASE_ST(ut_setup, ut_teardown,
15459                         test_AES_CCM_authenticated_decryption_test_case_128_1),
15460                 TEST_CASE_ST(ut_setup, ut_teardown,
15461                         test_AES_CCM_authenticated_decryption_test_case_128_2),
15462                 TEST_CASE_ST(ut_setup, ut_teardown,
15463                         test_AES_CCM_authenticated_decryption_test_case_128_3),
15464
15465                 /** AES CCM Authenticated Encryption 192 bits key */
15466                 TEST_CASE_ST(ut_setup, ut_teardown,
15467                         test_AES_CCM_authenticated_encryption_test_case_192_1),
15468                 TEST_CASE_ST(ut_setup, ut_teardown,
15469                         test_AES_CCM_authenticated_encryption_test_case_192_2),
15470                 TEST_CASE_ST(ut_setup, ut_teardown,
15471                         test_AES_CCM_authenticated_encryption_test_case_192_3),
15472
15473                 /** AES CCM Authenticated Decryption 192 bits key*/
15474                 TEST_CASE_ST(ut_setup, ut_teardown,
15475                         test_AES_CCM_authenticated_decryption_test_case_192_1),
15476                 TEST_CASE_ST(ut_setup, ut_teardown,
15477                         test_AES_CCM_authenticated_decryption_test_case_192_2),
15478                 TEST_CASE_ST(ut_setup, ut_teardown,
15479                         test_AES_CCM_authenticated_decryption_test_case_192_3),
15480
15481                 /** AES CCM Authenticated Encryption 256 bits key */
15482                 TEST_CASE_ST(ut_setup, ut_teardown,
15483                         test_AES_CCM_authenticated_encryption_test_case_256_1),
15484                 TEST_CASE_ST(ut_setup, ut_teardown,
15485                         test_AES_CCM_authenticated_encryption_test_case_256_2),
15486                 TEST_CASE_ST(ut_setup, ut_teardown,
15487                         test_AES_CCM_authenticated_encryption_test_case_256_3),
15488
15489                 /** AES CCM Authenticated Decryption 256 bits key*/
15490                 TEST_CASE_ST(ut_setup, ut_teardown,
15491                         test_AES_CCM_authenticated_decryption_test_case_256_1),
15492                 TEST_CASE_ST(ut_setup, ut_teardown,
15493                         test_AES_CCM_authenticated_decryption_test_case_256_2),
15494                 TEST_CASE_ST(ut_setup, ut_teardown,
15495                         test_AES_CCM_authenticated_decryption_test_case_256_3),
15496                 TEST_CASES_END()
15497         }
15498 };
15499
15500 static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite  = {
15501         .suite_name = "AES GCM Authenticated Test Suite",
15502         .setup = aes_gcm_auth_testsuite_setup,
15503         .unit_test_cases = {
15504                 /** AES GCM Authenticated Encryption */
15505                 TEST_CASE_ST(ut_setup, ut_teardown,
15506                         test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
15507                 TEST_CASE_ST(ut_setup, ut_teardown,
15508                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_400B),
15509                 TEST_CASE_ST(ut_setup, ut_teardown,
15510                         test_AES_GCM_auth_encrypt_SGL_out_of_place_1500B_2000B),
15511                 TEST_CASE_ST(ut_setup, ut_teardown,
15512                         test_AES_GCM_auth_encrypt_SGL_out_of_place_400B_1seg),
15513                 TEST_CASE_ST(ut_setup, ut_teardown,
15514                         test_AES_GCM_authenticated_encryption_test_case_1),
15515                 TEST_CASE_ST(ut_setup, ut_teardown,
15516                         test_AES_GCM_authenticated_encryption_test_case_2),
15517                 TEST_CASE_ST(ut_setup, ut_teardown,
15518                         test_AES_GCM_authenticated_encryption_test_case_3),
15519                 TEST_CASE_ST(ut_setup, ut_teardown,
15520                         test_AES_GCM_authenticated_encryption_test_case_4),
15521                 TEST_CASE_ST(ut_setup, ut_teardown,
15522                         test_AES_GCM_authenticated_encryption_test_case_5),
15523                 TEST_CASE_ST(ut_setup, ut_teardown,
15524                         test_AES_GCM_authenticated_encryption_test_case_6),
15525                 TEST_CASE_ST(ut_setup, ut_teardown,
15526                         test_AES_GCM_authenticated_encryption_test_case_7),
15527                 TEST_CASE_ST(ut_setup, ut_teardown,
15528                         test_AES_GCM_authenticated_encryption_test_case_8),
15529                 TEST_CASE_ST(ut_setup, ut_teardown,
15530                         test_AES_GCM_J0_authenticated_encryption_test_case_1),
15531
15532                 /** AES GCM Authenticated Decryption */
15533                 TEST_CASE_ST(ut_setup, ut_teardown,
15534                         test_AES_GCM_authenticated_decryption_test_case_1),
15535                 TEST_CASE_ST(ut_setup, ut_teardown,
15536                         test_AES_GCM_authenticated_decryption_test_case_2),
15537                 TEST_CASE_ST(ut_setup, ut_teardown,
15538                         test_AES_GCM_authenticated_decryption_test_case_3),
15539                 TEST_CASE_ST(ut_setup, ut_teardown,
15540                         test_AES_GCM_authenticated_decryption_test_case_4),
15541                 TEST_CASE_ST(ut_setup, ut_teardown,
15542                         test_AES_GCM_authenticated_decryption_test_case_5),
15543                 TEST_CASE_ST(ut_setup, ut_teardown,
15544                         test_AES_GCM_authenticated_decryption_test_case_6),
15545                 TEST_CASE_ST(ut_setup, ut_teardown,
15546                         test_AES_GCM_authenticated_decryption_test_case_7),
15547                 TEST_CASE_ST(ut_setup, ut_teardown,
15548                         test_AES_GCM_authenticated_decryption_test_case_8),
15549                 TEST_CASE_ST(ut_setup, ut_teardown,
15550                         test_AES_GCM_J0_authenticated_decryption_test_case_1),
15551
15552                 /** AES GCM Authenticated Encryption 192 bits key */
15553                 TEST_CASE_ST(ut_setup, ut_teardown,
15554                         test_AES_GCM_auth_encryption_test_case_192_1),
15555                 TEST_CASE_ST(ut_setup, ut_teardown,
15556                         test_AES_GCM_auth_encryption_test_case_192_2),
15557                 TEST_CASE_ST(ut_setup, ut_teardown,
15558                         test_AES_GCM_auth_encryption_test_case_192_3),
15559                 TEST_CASE_ST(ut_setup, ut_teardown,
15560                         test_AES_GCM_auth_encryption_test_case_192_4),
15561                 TEST_CASE_ST(ut_setup, ut_teardown,
15562                         test_AES_GCM_auth_encryption_test_case_192_5),
15563                 TEST_CASE_ST(ut_setup, ut_teardown,
15564                         test_AES_GCM_auth_encryption_test_case_192_6),
15565                 TEST_CASE_ST(ut_setup, ut_teardown,
15566                         test_AES_GCM_auth_encryption_test_case_192_7),
15567
15568                 /** AES GCM Authenticated Decryption 192 bits key */
15569                 TEST_CASE_ST(ut_setup, ut_teardown,
15570                         test_AES_GCM_auth_decryption_test_case_192_1),
15571                 TEST_CASE_ST(ut_setup, ut_teardown,
15572                         test_AES_GCM_auth_decryption_test_case_192_2),
15573                 TEST_CASE_ST(ut_setup, ut_teardown,
15574                         test_AES_GCM_auth_decryption_test_case_192_3),
15575                 TEST_CASE_ST(ut_setup, ut_teardown,
15576                         test_AES_GCM_auth_decryption_test_case_192_4),
15577                 TEST_CASE_ST(ut_setup, ut_teardown,
15578                         test_AES_GCM_auth_decryption_test_case_192_5),
15579                 TEST_CASE_ST(ut_setup, ut_teardown,
15580                         test_AES_GCM_auth_decryption_test_case_192_6),
15581                 TEST_CASE_ST(ut_setup, ut_teardown,
15582                         test_AES_GCM_auth_decryption_test_case_192_7),
15583
15584                 /** AES GCM Authenticated Encryption 256 bits key */
15585                 TEST_CASE_ST(ut_setup, ut_teardown,
15586                         test_AES_GCM_auth_encryption_test_case_256_1),
15587                 TEST_CASE_ST(ut_setup, ut_teardown,
15588                         test_AES_GCM_auth_encryption_test_case_256_2),
15589                 TEST_CASE_ST(ut_setup, ut_teardown,
15590                         test_AES_GCM_auth_encryption_test_case_256_3),
15591                 TEST_CASE_ST(ut_setup, ut_teardown,
15592                         test_AES_GCM_auth_encryption_test_case_256_4),
15593                 TEST_CASE_ST(ut_setup, ut_teardown,
15594                         test_AES_GCM_auth_encryption_test_case_256_5),
15595                 TEST_CASE_ST(ut_setup, ut_teardown,
15596                         test_AES_GCM_auth_encryption_test_case_256_6),
15597                 TEST_CASE_ST(ut_setup, ut_teardown,
15598                         test_AES_GCM_auth_encryption_test_case_256_7),
15599
15600                 /** AES GCM Authenticated Decryption 256 bits key */
15601                 TEST_CASE_ST(ut_setup, ut_teardown,
15602                         test_AES_GCM_auth_decryption_test_case_256_1),
15603                 TEST_CASE_ST(ut_setup, ut_teardown,
15604                         test_AES_GCM_auth_decryption_test_case_256_2),
15605                 TEST_CASE_ST(ut_setup, ut_teardown,
15606                         test_AES_GCM_auth_decryption_test_case_256_3),
15607                 TEST_CASE_ST(ut_setup, ut_teardown,
15608                         test_AES_GCM_auth_decryption_test_case_256_4),
15609                 TEST_CASE_ST(ut_setup, ut_teardown,
15610                         test_AES_GCM_auth_decryption_test_case_256_5),
15611                 TEST_CASE_ST(ut_setup, ut_teardown,
15612                         test_AES_GCM_auth_decryption_test_case_256_6),
15613                 TEST_CASE_ST(ut_setup, ut_teardown,
15614                         test_AES_GCM_auth_decryption_test_case_256_7),
15615
15616                 /** AES GCM Authenticated Encryption big aad size */
15617                 TEST_CASE_ST(ut_setup, ut_teardown,
15618                         test_AES_GCM_auth_encryption_test_case_aad_1),
15619                 TEST_CASE_ST(ut_setup, ut_teardown,
15620                         test_AES_GCM_auth_encryption_test_case_aad_2),
15621
15622                 /** AES GCM Authenticated Decryption big aad size */
15623                 TEST_CASE_ST(ut_setup, ut_teardown,
15624                         test_AES_GCM_auth_decryption_test_case_aad_1),
15625                 TEST_CASE_ST(ut_setup, ut_teardown,
15626                         test_AES_GCM_auth_decryption_test_case_aad_2),
15627
15628                 /** Out of place tests */
15629                 TEST_CASE_ST(ut_setup, ut_teardown,
15630                         test_AES_GCM_authenticated_encryption_oop_test_case_1),
15631                 TEST_CASE_ST(ut_setup, ut_teardown,
15632                         test_AES_GCM_authenticated_decryption_oop_test_case_1),
15633
15634                 /** Session-less tests */
15635                 TEST_CASE_ST(ut_setup, ut_teardown,
15636                         test_AES_GCM_authenticated_encryption_sessionless_test_case_1),
15637                 TEST_CASE_ST(ut_setup, ut_teardown,
15638                         test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
15639
15640                 TEST_CASES_END()
15641         }
15642 };
15643
15644 static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite  = {
15645         .suite_name = "AES GMAC Authentication Test Suite",
15646         .setup = aes_gmac_auth_testsuite_setup,
15647         .unit_test_cases = {
15648                 TEST_CASE_ST(ut_setup, ut_teardown,
15649                         test_AES_GMAC_authentication_test_case_1),
15650                 TEST_CASE_ST(ut_setup, ut_teardown,
15651                         test_AES_GMAC_authentication_verify_test_case_1),
15652                 TEST_CASE_ST(ut_setup, ut_teardown,
15653                         test_AES_GMAC_authentication_test_case_2),
15654                 TEST_CASE_ST(ut_setup, ut_teardown,
15655                         test_AES_GMAC_authentication_verify_test_case_2),
15656                 TEST_CASE_ST(ut_setup, ut_teardown,
15657                         test_AES_GMAC_authentication_test_case_3),
15658                 TEST_CASE_ST(ut_setup, ut_teardown,
15659                         test_AES_GMAC_authentication_verify_test_case_3),
15660                 TEST_CASE_ST(ut_setup, ut_teardown,
15661                         test_AES_GMAC_authentication_test_case_4),
15662                 TEST_CASE_ST(ut_setup, ut_teardown,
15663                         test_AES_GMAC_authentication_verify_test_case_4),
15664                 TEST_CASE_ST(ut_setup, ut_teardown,
15665                         test_AES_GMAC_authentication_SGL_40B),
15666                 TEST_CASE_ST(ut_setup, ut_teardown,
15667                         test_AES_GMAC_authentication_SGL_80B),
15668                 TEST_CASE_ST(ut_setup, ut_teardown,
15669                         test_AES_GMAC_authentication_SGL_2048B),
15670                 TEST_CASE_ST(ut_setup, ut_teardown,
15671                         test_AES_GMAC_authentication_SGL_2047B),
15672
15673                 TEST_CASES_END()
15674         }
15675 };
15676
15677 static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite  = {
15678         .suite_name = "Chacha20-Poly1305 Test Suite",
15679         .setup = chacha20_poly1305_testsuite_setup,
15680         .unit_test_cases = {
15681                 TEST_CASE_ST(ut_setup, ut_teardown,
15682                         test_chacha20_poly1305_encrypt_test_case_rfc8439),
15683                 TEST_CASE_ST(ut_setup, ut_teardown,
15684                         test_chacha20_poly1305_decrypt_test_case_rfc8439),
15685                 TEST_CASE_ST(ut_setup, ut_teardown,
15686                         test_chacha20_poly1305_encrypt_SGL_out_of_place),
15687                 TEST_CASES_END()
15688         }
15689 };
15690
15691 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
15692         .suite_name = "SNOW 3G Test Suite",
15693         .setup = snow3g_testsuite_setup,
15694         .unit_test_cases = {
15695                 /** SNOW 3G encrypt only (UEA2) */
15696                 TEST_CASE_ST(ut_setup, ut_teardown,
15697                         test_snow3g_encryption_test_case_1),
15698                 TEST_CASE_ST(ut_setup, ut_teardown,
15699                         test_snow3g_encryption_test_case_2),
15700                 TEST_CASE_ST(ut_setup, ut_teardown,
15701                         test_snow3g_encryption_test_case_3),
15702                 TEST_CASE_ST(ut_setup, ut_teardown,
15703                         test_snow3g_encryption_test_case_4),
15704                 TEST_CASE_ST(ut_setup, ut_teardown,
15705                         test_snow3g_encryption_test_case_5),
15706
15707                 TEST_CASE_ST(ut_setup, ut_teardown,
15708                         test_snow3g_encryption_test_case_1_oop),
15709                 TEST_CASE_ST(ut_setup, ut_teardown,
15710                         test_snow3g_encryption_test_case_1_oop_sgl),
15711                 TEST_CASE_ST(ut_setup, ut_teardown,
15712                         test_snow3g_encryption_test_case_1_offset_oop),
15713                 TEST_CASE_ST(ut_setup, ut_teardown,
15714                         test_snow3g_decryption_test_case_1_oop),
15715
15716                 /** SNOW 3G generate auth, then encrypt (UEA2) */
15717                 TEST_CASE_ST(ut_setup, ut_teardown,
15718                         test_snow3g_auth_cipher_test_case_1),
15719                 TEST_CASE_ST(ut_setup, ut_teardown,
15720                         test_snow3g_auth_cipher_test_case_2),
15721                 TEST_CASE_ST(ut_setup, ut_teardown,
15722                         test_snow3g_auth_cipher_test_case_2_oop),
15723                 TEST_CASE_ST(ut_setup, ut_teardown,
15724                         test_snow3g_auth_cipher_part_digest_enc),
15725                 TEST_CASE_ST(ut_setup, ut_teardown,
15726                         test_snow3g_auth_cipher_part_digest_enc_oop),
15727                 TEST_CASE_ST(ut_setup, ut_teardown,
15728                         test_snow3g_auth_cipher_test_case_3_sgl),
15729                 TEST_CASE_ST(ut_setup, ut_teardown,
15730                         test_snow3g_auth_cipher_test_case_3_oop_sgl),
15731                 TEST_CASE_ST(ut_setup, ut_teardown,
15732                         test_snow3g_auth_cipher_part_digest_enc_sgl),
15733                 TEST_CASE_ST(ut_setup, ut_teardown,
15734                         test_snow3g_auth_cipher_part_digest_enc_oop_sgl),
15735
15736                 /** SNOW 3G decrypt (UEA2), then verify auth */
15737                 TEST_CASE_ST(ut_setup, ut_teardown,
15738                         test_snow3g_auth_cipher_verify_test_case_1),
15739                 TEST_CASE_ST(ut_setup, ut_teardown,
15740                         test_snow3g_auth_cipher_verify_test_case_2),
15741                 TEST_CASE_ST(ut_setup, ut_teardown,
15742                         test_snow3g_auth_cipher_verify_test_case_2_oop),
15743                 TEST_CASE_ST(ut_setup, ut_teardown,
15744                         test_snow3g_auth_cipher_verify_part_digest_enc),
15745                 TEST_CASE_ST(ut_setup, ut_teardown,
15746                         test_snow3g_auth_cipher_verify_part_digest_enc_oop),
15747                 TEST_CASE_ST(ut_setup, ut_teardown,
15748                         test_snow3g_auth_cipher_verify_test_case_3_sgl),
15749                 TEST_CASE_ST(ut_setup, ut_teardown,
15750                         test_snow3g_auth_cipher_verify_test_case_3_oop_sgl),
15751                 TEST_CASE_ST(ut_setup, ut_teardown,
15752                         test_snow3g_auth_cipher_verify_part_digest_enc_sgl),
15753                 TEST_CASE_ST(ut_setup, ut_teardown,
15754                         test_snow3g_auth_cipher_verify_part_digest_enc_oop_sgl),
15755
15756                 /** SNOW 3G decrypt only (UEA2) */
15757                 TEST_CASE_ST(ut_setup, ut_teardown,
15758                         test_snow3g_decryption_test_case_1),
15759                 TEST_CASE_ST(ut_setup, ut_teardown,
15760                         test_snow3g_decryption_test_case_2),
15761                 TEST_CASE_ST(ut_setup, ut_teardown,
15762                         test_snow3g_decryption_test_case_3),
15763                 TEST_CASE_ST(ut_setup, ut_teardown,
15764                         test_snow3g_decryption_test_case_4),
15765                 TEST_CASE_ST(ut_setup, ut_teardown,
15766                         test_snow3g_decryption_test_case_5),
15767                 TEST_CASE_ST(ut_setup, ut_teardown,
15768                         test_snow3g_decryption_with_digest_test_case_1),
15769                 TEST_CASE_ST(ut_setup, ut_teardown,
15770                         test_snow3g_hash_generate_test_case_1),
15771                 TEST_CASE_ST(ut_setup, ut_teardown,
15772                         test_snow3g_hash_generate_test_case_2),
15773                 TEST_CASE_ST(ut_setup, ut_teardown,
15774                         test_snow3g_hash_generate_test_case_3),
15775
15776                 /* Tests with buffers which length is not byte-aligned */
15777                 TEST_CASE_ST(ut_setup, ut_teardown,
15778                         test_snow3g_hash_generate_test_case_4),
15779                 TEST_CASE_ST(ut_setup, ut_teardown,
15780                         test_snow3g_hash_generate_test_case_5),
15781                 TEST_CASE_ST(ut_setup, ut_teardown,
15782                         test_snow3g_hash_generate_test_case_6),
15783                 TEST_CASE_ST(ut_setup, ut_teardown,
15784                         test_snow3g_hash_verify_test_case_1),
15785                 TEST_CASE_ST(ut_setup, ut_teardown,
15786                         test_snow3g_hash_verify_test_case_2),
15787                 TEST_CASE_ST(ut_setup, ut_teardown,
15788                         test_snow3g_hash_verify_test_case_3),
15789
15790                 /* Tests with buffers which length is not byte-aligned */
15791                 TEST_CASE_ST(ut_setup, ut_teardown,
15792                         test_snow3g_hash_verify_test_case_4),
15793                 TEST_CASE_ST(ut_setup, ut_teardown,
15794                         test_snow3g_hash_verify_test_case_5),
15795                 TEST_CASE_ST(ut_setup, ut_teardown,
15796                         test_snow3g_hash_verify_test_case_6),
15797                 TEST_CASE_ST(ut_setup, ut_teardown,
15798                         test_snow3g_cipher_auth_test_case_1),
15799                 TEST_CASE_ST(ut_setup, ut_teardown,
15800                         test_snow3g_auth_cipher_with_digest_test_case_1),
15801                 TEST_CASES_END()
15802         }
15803 };
15804
15805 static struct unit_test_suite cryptodev_zuc_testsuite  = {
15806         .suite_name = "ZUC Test Suite",
15807         .setup = zuc_testsuite_setup,
15808         .unit_test_cases = {
15809                 /** ZUC encrypt only (EEA3) */
15810                 TEST_CASE_ST(ut_setup, ut_teardown,
15811                         test_zuc_encryption_test_case_1),
15812                 TEST_CASE_ST(ut_setup, ut_teardown,
15813                         test_zuc_encryption_test_case_2),
15814                 TEST_CASE_ST(ut_setup, ut_teardown,
15815                         test_zuc_encryption_test_case_3),
15816                 TEST_CASE_ST(ut_setup, ut_teardown,
15817                         test_zuc_encryption_test_case_4),
15818                 TEST_CASE_ST(ut_setup, ut_teardown,
15819                         test_zuc_encryption_test_case_5),
15820                 TEST_CASE_ST(ut_setup, ut_teardown,
15821                         test_zuc_encryption_test_case_6_sgl),
15822
15823                 /** ZUC authenticate (EIA3) */
15824                 TEST_CASE_ST(ut_setup, ut_teardown,
15825                         test_zuc_hash_generate_test_case_1),
15826                 TEST_CASE_ST(ut_setup, ut_teardown,
15827                         test_zuc_hash_generate_test_case_2),
15828                 TEST_CASE_ST(ut_setup, ut_teardown,
15829                         test_zuc_hash_generate_test_case_3),
15830                 TEST_CASE_ST(ut_setup, ut_teardown,
15831                         test_zuc_hash_generate_test_case_4),
15832                 TEST_CASE_ST(ut_setup, ut_teardown,
15833                         test_zuc_hash_generate_test_case_5),
15834                 TEST_CASE_ST(ut_setup, ut_teardown,
15835                         test_zuc_hash_generate_test_case_6),
15836                 TEST_CASE_ST(ut_setup, ut_teardown,
15837                         test_zuc_hash_generate_test_case_7),
15838                 TEST_CASE_ST(ut_setup, ut_teardown,
15839                         test_zuc_hash_generate_test_case_8),
15840                 TEST_CASE_ST(ut_setup, ut_teardown,
15841                         test_zuc_hash_generate_test_case_9),
15842                 TEST_CASE_ST(ut_setup, ut_teardown,
15843                         test_zuc_hash_generate_test_case_10),
15844                 TEST_CASE_ST(ut_setup, ut_teardown,
15845                         test_zuc_hash_generate_test_case_11),
15846
15847
15848                 /** ZUC alg-chain (EEA3/EIA3) */
15849                 TEST_CASE_ST(ut_setup, ut_teardown,
15850                         test_zuc_cipher_auth_test_case_1),
15851                 TEST_CASE_ST(ut_setup, ut_teardown,
15852                         test_zuc_cipher_auth_test_case_2),
15853
15854                 /** ZUC generate auth, then encrypt (EEA3) */
15855                 TEST_CASE_ST(ut_setup, ut_teardown,
15856                         test_zuc_auth_cipher_test_case_1),
15857                 TEST_CASE_ST(ut_setup, ut_teardown,
15858                         test_zuc_auth_cipher_test_case_1_oop),
15859                 TEST_CASE_ST(ut_setup, ut_teardown,
15860                         test_zuc_auth_cipher_test_case_1_sgl),
15861                 TEST_CASE_ST(ut_setup, ut_teardown,
15862                         test_zuc_auth_cipher_test_case_1_oop_sgl),
15863
15864                 /** ZUC decrypt (EEA3), then verify auth */
15865                 TEST_CASE_ST(ut_setup, ut_teardown,
15866                         test_zuc_auth_cipher_verify_test_case_1),
15867                 TEST_CASE_ST(ut_setup, ut_teardown,
15868                         test_zuc_auth_cipher_verify_test_case_1_oop),
15869                 TEST_CASE_ST(ut_setup, ut_teardown,
15870                         test_zuc_auth_cipher_verify_test_case_1_sgl),
15871                 TEST_CASE_ST(ut_setup, ut_teardown,
15872                         test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
15873
15874                 /** ZUC-256 encrypt only **/
15875                 TEST_CASE_ST(ut_setup, ut_teardown,
15876                         test_zuc256_encryption_test_case_1),
15877                 TEST_CASE_ST(ut_setup, ut_teardown,
15878                         test_zuc256_encryption_test_case_2),
15879
15880                 /** ZUC-256 authentication only **/
15881                 TEST_CASE_ST(ut_setup, ut_teardown,
15882                         test_zuc256_authentication_test_case_1),
15883                 TEST_CASE_ST(ut_setup, ut_teardown,
15884                         test_zuc256_authentication_test_case_2),
15885
15886                 TEST_CASES_END()
15887         }
15888 };
15889
15890 static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite  = {
15891         .suite_name = "HMAC_MD5 Authentication Test Suite",
15892         .setup = hmac_md5_auth_testsuite_setup,
15893         .unit_test_cases = {
15894                 TEST_CASE_ST(ut_setup, ut_teardown,
15895                         test_MD5_HMAC_generate_case_1),
15896                 TEST_CASE_ST(ut_setup, ut_teardown,
15897                         test_MD5_HMAC_verify_case_1),
15898                 TEST_CASE_ST(ut_setup, ut_teardown,
15899                         test_MD5_HMAC_generate_case_2),
15900                 TEST_CASE_ST(ut_setup, ut_teardown,
15901                         test_MD5_HMAC_verify_case_2),
15902                 TEST_CASES_END()
15903         }
15904 };
15905
15906 static struct unit_test_suite cryptodev_kasumi_testsuite  = {
15907         .suite_name = "Kasumi Test Suite",
15908         .setup = kasumi_testsuite_setup,
15909         .unit_test_cases = {
15910                 /** KASUMI hash only (UIA1) */
15911                 TEST_CASE_ST(ut_setup, ut_teardown,
15912                         test_kasumi_hash_generate_test_case_1),
15913                 TEST_CASE_ST(ut_setup, ut_teardown,
15914                         test_kasumi_hash_generate_test_case_2),
15915                 TEST_CASE_ST(ut_setup, ut_teardown,
15916                         test_kasumi_hash_generate_test_case_3),
15917                 TEST_CASE_ST(ut_setup, ut_teardown,
15918                         test_kasumi_hash_generate_test_case_4),
15919                 TEST_CASE_ST(ut_setup, ut_teardown,
15920                         test_kasumi_hash_generate_test_case_5),
15921                 TEST_CASE_ST(ut_setup, ut_teardown,
15922                         test_kasumi_hash_generate_test_case_6),
15923
15924                 TEST_CASE_ST(ut_setup, ut_teardown,
15925                         test_kasumi_hash_verify_test_case_1),
15926                 TEST_CASE_ST(ut_setup, ut_teardown,
15927                         test_kasumi_hash_verify_test_case_2),
15928                 TEST_CASE_ST(ut_setup, ut_teardown,
15929                         test_kasumi_hash_verify_test_case_3),
15930                 TEST_CASE_ST(ut_setup, ut_teardown,
15931                         test_kasumi_hash_verify_test_case_4),
15932                 TEST_CASE_ST(ut_setup, ut_teardown,
15933                         test_kasumi_hash_verify_test_case_5),
15934
15935                 /** KASUMI encrypt only (UEA1) */
15936                 TEST_CASE_ST(ut_setup, ut_teardown,
15937                         test_kasumi_encryption_test_case_1),
15938                 TEST_CASE_ST(ut_setup, ut_teardown,
15939                         test_kasumi_encryption_test_case_1_sgl),
15940                 TEST_CASE_ST(ut_setup, ut_teardown,
15941                         test_kasumi_encryption_test_case_1_oop),
15942                 TEST_CASE_ST(ut_setup, ut_teardown,
15943                         test_kasumi_encryption_test_case_1_oop_sgl),
15944                 TEST_CASE_ST(ut_setup, ut_teardown,
15945                         test_kasumi_encryption_test_case_2),
15946                 TEST_CASE_ST(ut_setup, ut_teardown,
15947                         test_kasumi_encryption_test_case_3),
15948                 TEST_CASE_ST(ut_setup, ut_teardown,
15949                         test_kasumi_encryption_test_case_4),
15950                 TEST_CASE_ST(ut_setup, ut_teardown,
15951                         test_kasumi_encryption_test_case_5),
15952
15953                 /** KASUMI decrypt only (UEA1) */
15954                 TEST_CASE_ST(ut_setup, ut_teardown,
15955                         test_kasumi_decryption_test_case_1),
15956                 TEST_CASE_ST(ut_setup, ut_teardown,
15957                         test_kasumi_decryption_test_case_2),
15958                 TEST_CASE_ST(ut_setup, ut_teardown,
15959                         test_kasumi_decryption_test_case_3),
15960                 TEST_CASE_ST(ut_setup, ut_teardown,
15961                         test_kasumi_decryption_test_case_4),
15962                 TEST_CASE_ST(ut_setup, ut_teardown,
15963                         test_kasumi_decryption_test_case_5),
15964                 TEST_CASE_ST(ut_setup, ut_teardown,
15965                         test_kasumi_decryption_test_case_1_oop),
15966                 TEST_CASE_ST(ut_setup, ut_teardown,
15967                         test_kasumi_cipher_auth_test_case_1),
15968
15969                 /** KASUMI generate auth, then encrypt (F8) */
15970                 TEST_CASE_ST(ut_setup, ut_teardown,
15971                         test_kasumi_auth_cipher_test_case_1),
15972                 TEST_CASE_ST(ut_setup, ut_teardown,
15973                         test_kasumi_auth_cipher_test_case_2),
15974                 TEST_CASE_ST(ut_setup, ut_teardown,
15975                         test_kasumi_auth_cipher_test_case_2_oop),
15976                 TEST_CASE_ST(ut_setup, ut_teardown,
15977                         test_kasumi_auth_cipher_test_case_2_sgl),
15978                 TEST_CASE_ST(ut_setup, ut_teardown,
15979                         test_kasumi_auth_cipher_test_case_2_oop_sgl),
15980
15981                 /** KASUMI decrypt (F8), then verify auth */
15982                 TEST_CASE_ST(ut_setup, ut_teardown,
15983                         test_kasumi_auth_cipher_verify_test_case_1),
15984                 TEST_CASE_ST(ut_setup, ut_teardown,
15985                         test_kasumi_auth_cipher_verify_test_case_2),
15986                 TEST_CASE_ST(ut_setup, ut_teardown,
15987                         test_kasumi_auth_cipher_verify_test_case_2_oop),
15988                 TEST_CASE_ST(ut_setup, ut_teardown,
15989                         test_kasumi_auth_cipher_verify_test_case_2_sgl),
15990                 TEST_CASE_ST(ut_setup, ut_teardown,
15991                         test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
15992
15993                 TEST_CASES_END()
15994         }
15995 };
15996
15997 static struct unit_test_suite cryptodev_esn_testsuite  = {
15998         .suite_name = "ESN Test Suite",
15999         .setup = esn_testsuite_setup,
16000         .unit_test_cases = {
16001                 TEST_CASE_ST(ut_setup, ut_teardown,
16002                         auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
16003                 TEST_CASE_ST(ut_setup, ut_teardown,
16004                         auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
16005                 TEST_CASES_END()
16006         }
16007 };
16008
16009 static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite  = {
16010         .suite_name = "Negative AES GCM Test Suite",
16011         .setup = negative_aes_gcm_testsuite_setup,
16012         .unit_test_cases = {
16013                 TEST_CASE_ST(ut_setup, ut_teardown,
16014                         test_AES_GCM_auth_encryption_fail_iv_corrupt),
16015                 TEST_CASE_ST(ut_setup, ut_teardown,
16016                         test_AES_GCM_auth_encryption_fail_in_data_corrupt),
16017                 TEST_CASE_ST(ut_setup, ut_teardown,
16018                         test_AES_GCM_auth_encryption_fail_out_data_corrupt),
16019                 TEST_CASE_ST(ut_setup, ut_teardown,
16020                         test_AES_GCM_auth_encryption_fail_aad_len_corrupt),
16021                 TEST_CASE_ST(ut_setup, ut_teardown,
16022                         test_AES_GCM_auth_encryption_fail_aad_corrupt),
16023                 TEST_CASE_ST(ut_setup, ut_teardown,
16024                         test_AES_GCM_auth_encryption_fail_tag_corrupt),
16025                 TEST_CASE_ST(ut_setup, ut_teardown,
16026                         test_AES_GCM_auth_decryption_fail_iv_corrupt),
16027                 TEST_CASE_ST(ut_setup, ut_teardown,
16028                         test_AES_GCM_auth_decryption_fail_in_data_corrupt),
16029                 TEST_CASE_ST(ut_setup, ut_teardown,
16030                         test_AES_GCM_auth_decryption_fail_out_data_corrupt),
16031                 TEST_CASE_ST(ut_setup, ut_teardown,
16032                         test_AES_GCM_auth_decryption_fail_aad_len_corrupt),
16033                 TEST_CASE_ST(ut_setup, ut_teardown,
16034                         test_AES_GCM_auth_decryption_fail_aad_corrupt),
16035                 TEST_CASE_ST(ut_setup, ut_teardown,
16036                         test_AES_GCM_auth_decryption_fail_tag_corrupt),
16037
16038                 TEST_CASES_END()
16039         }
16040 };
16041
16042 static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite  = {
16043         .suite_name = "Negative AES GMAC Test Suite",
16044         .setup = negative_aes_gmac_testsuite_setup,
16045         .unit_test_cases = {
16046                 TEST_CASE_ST(ut_setup, ut_teardown,
16047                         authentication_verify_AES128_GMAC_fail_data_corrupt),
16048                 TEST_CASE_ST(ut_setup, ut_teardown,
16049                         authentication_verify_AES128_GMAC_fail_tag_corrupt),
16050
16051                 TEST_CASES_END()
16052         }
16053 };
16054
16055 static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite  = {
16056         .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
16057         .setup = mixed_cipher_hash_testsuite_setup,
16058         .unit_test_cases = {
16059                 /** AUTH AES CMAC + CIPHER AES CTR */
16060                 TEST_CASE_ST(ut_setup, ut_teardown,
16061                         test_aes_cmac_aes_ctr_digest_enc_test_case_1),
16062                 TEST_CASE_ST(ut_setup, ut_teardown,
16063                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16064                 TEST_CASE_ST(ut_setup, ut_teardown,
16065                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16066                 TEST_CASE_ST(ut_setup, ut_teardown,
16067                         test_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16068                 TEST_CASE_ST(ut_setup, ut_teardown,
16069                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
16070                 TEST_CASE_ST(ut_setup, ut_teardown,
16071                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
16072                 TEST_CASE_ST(ut_setup, ut_teardown,
16073                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
16074                 TEST_CASE_ST(ut_setup, ut_teardown,
16075                         test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
16076
16077                 /** AUTH ZUC + CIPHER SNOW3G */
16078                 TEST_CASE_ST(ut_setup, ut_teardown,
16079                         test_auth_zuc_cipher_snow_test_case_1),
16080                 TEST_CASE_ST(ut_setup, ut_teardown,
16081                         test_verify_auth_zuc_cipher_snow_test_case_1),
16082                 /** AUTH AES CMAC + CIPHER SNOW3G */
16083                 TEST_CASE_ST(ut_setup, ut_teardown,
16084                         test_auth_aes_cmac_cipher_snow_test_case_1),
16085                 TEST_CASE_ST(ut_setup, ut_teardown,
16086                         test_verify_auth_aes_cmac_cipher_snow_test_case_1),
16087                 /** AUTH ZUC + CIPHER AES CTR */
16088                 TEST_CASE_ST(ut_setup, ut_teardown,
16089                         test_auth_zuc_cipher_aes_ctr_test_case_1),
16090                 TEST_CASE_ST(ut_setup, ut_teardown,
16091                         test_verify_auth_zuc_cipher_aes_ctr_test_case_1),
16092                 /** AUTH SNOW3G + CIPHER AES CTR */
16093                 TEST_CASE_ST(ut_setup, ut_teardown,
16094                         test_auth_snow_cipher_aes_ctr_test_case_1),
16095                 TEST_CASE_ST(ut_setup, ut_teardown,
16096                         test_verify_auth_snow_cipher_aes_ctr_test_case_1),
16097                 /** AUTH SNOW3G + CIPHER ZUC */
16098                 TEST_CASE_ST(ut_setup, ut_teardown,
16099                         test_auth_snow_cipher_zuc_test_case_1),
16100                 TEST_CASE_ST(ut_setup, ut_teardown,
16101                         test_verify_auth_snow_cipher_zuc_test_case_1),
16102                 /** AUTH AES CMAC + CIPHER ZUC */
16103                 TEST_CASE_ST(ut_setup, ut_teardown,
16104                         test_auth_aes_cmac_cipher_zuc_test_case_1),
16105                 TEST_CASE_ST(ut_setup, ut_teardown,
16106                         test_verify_auth_aes_cmac_cipher_zuc_test_case_1),
16107
16108                 /** AUTH NULL + CIPHER SNOW3G */
16109                 TEST_CASE_ST(ut_setup, ut_teardown,
16110                         test_auth_null_cipher_snow_test_case_1),
16111                 TEST_CASE_ST(ut_setup, ut_teardown,
16112                         test_verify_auth_null_cipher_snow_test_case_1),
16113                 /** AUTH NULL + CIPHER ZUC */
16114                 TEST_CASE_ST(ut_setup, ut_teardown,
16115                         test_auth_null_cipher_zuc_test_case_1),
16116                 TEST_CASE_ST(ut_setup, ut_teardown,
16117                         test_verify_auth_null_cipher_zuc_test_case_1),
16118                 /** AUTH SNOW3G + CIPHER NULL */
16119                 TEST_CASE_ST(ut_setup, ut_teardown,
16120                         test_auth_snow_cipher_null_test_case_1),
16121                 TEST_CASE_ST(ut_setup, ut_teardown,
16122                         test_verify_auth_snow_cipher_null_test_case_1),
16123                 /** AUTH ZUC + CIPHER NULL */
16124                 TEST_CASE_ST(ut_setup, ut_teardown,
16125                         test_auth_zuc_cipher_null_test_case_1),
16126                 TEST_CASE_ST(ut_setup, ut_teardown,
16127                         test_verify_auth_zuc_cipher_null_test_case_1),
16128                 /** AUTH NULL + CIPHER AES CTR */
16129                 TEST_CASE_ST(ut_setup, ut_teardown,
16130                         test_auth_null_cipher_aes_ctr_test_case_1),
16131                 TEST_CASE_ST(ut_setup, ut_teardown,
16132                         test_verify_auth_null_cipher_aes_ctr_test_case_1),
16133                 /** AUTH AES CMAC + CIPHER NULL */
16134                 TEST_CASE_ST(ut_setup, ut_teardown,
16135                         test_auth_aes_cmac_cipher_null_test_case_1),
16136                 TEST_CASE_ST(ut_setup, ut_teardown,
16137                         test_verify_auth_aes_cmac_cipher_null_test_case_1),
16138                 TEST_CASES_END()
16139         }
16140 };
16141
16142 static int
16143 run_cryptodev_testsuite(const char *pmd_name)
16144 {
16145         uint8_t ret, j, i = 0, blk_start_idx = 0;
16146         const enum blockcipher_test_type blk_suites[] = {
16147                 BLKCIPHER_AES_CHAIN_TYPE,
16148                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16149                 BLKCIPHER_AES_DOCSIS_TYPE,
16150                 BLKCIPHER_3DES_CHAIN_TYPE,
16151                 BLKCIPHER_3DES_CIPHERONLY_TYPE,
16152                 BLKCIPHER_DES_CIPHERONLY_TYPE,
16153                 BLKCIPHER_DES_DOCSIS_TYPE,
16154                 BLKCIPHER_AUTHONLY_TYPE};
16155         struct unit_test_suite *static_suites[] = {
16156                 &cryptodev_multi_session_testsuite,
16157                 &cryptodev_null_testsuite,
16158                 &cryptodev_aes_ccm_auth_testsuite,
16159                 &cryptodev_aes_gcm_auth_testsuite,
16160                 &cryptodev_aes_gmac_auth_testsuite,
16161                 &cryptodev_snow3g_testsuite,
16162                 &cryptodev_chacha20_poly1305_testsuite,
16163                 &cryptodev_zuc_testsuite,
16164                 &cryptodev_hmac_md5_auth_testsuite,
16165                 &cryptodev_kasumi_testsuite,
16166                 &cryptodev_esn_testsuite,
16167                 &cryptodev_negative_aes_gcm_testsuite,
16168                 &cryptodev_negative_aes_gmac_testsuite,
16169                 &cryptodev_mixed_cipher_hash_testsuite,
16170                 &cryptodev_negative_hmac_sha1_testsuite,
16171                 &cryptodev_gen_testsuite,
16172 #ifdef RTE_LIB_SECURITY
16173                 &ipsec_proto_testsuite,
16174                 &pdcp_proto_testsuite,
16175                 &docsis_proto_testsuite,
16176 #endif
16177                 &end_testsuite
16178         };
16179         static struct unit_test_suite ts = {
16180                 .suite_name = "Cryptodev Unit Test Suite",
16181                 .setup = testsuite_setup,
16182                 .teardown = testsuite_teardown,
16183                 .unit_test_cases = {TEST_CASES_END()}
16184         };
16185
16186         gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
16187
16188         if (gbl_driver_id == -1) {
16189                 RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
16190                 return TEST_SKIPPED;
16191         }
16192
16193         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16194                         (RTE_DIM(blk_suites) + RTE_DIM(static_suites)));
16195
16196         ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites));
16197         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16198         ret = unit_test_suite_runner(&ts);
16199
16200         FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites));
16201         free(ts.unit_test_suites);
16202         return ret;
16203 }
16204
16205 static int
16206 require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name)
16207 {
16208         struct rte_cryptodev_info dev_info;
16209         uint8_t i, nb_devs;
16210         int driver_id;
16211
16212         driver_id = rte_cryptodev_driver_id_get(pmd_name);
16213         if (driver_id == -1) {
16214                 RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name);
16215                 return TEST_SKIPPED;
16216         }
16217
16218         nb_devs = rte_cryptodev_count();
16219         if (nb_devs < 1) {
16220                 RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
16221                 return TEST_SKIPPED;
16222         }
16223
16224         for (i = 0; i < nb_devs; i++) {
16225                 rte_cryptodev_info_get(i, &dev_info);
16226                 if (dev_info.driver_id == driver_id) {
16227                         if (!(dev_info.feature_flags & flag)) {
16228                                 RTE_LOG(INFO, USER1, "%s not supported\n",
16229                                                 flag_name);
16230                                 return TEST_SKIPPED;
16231                         }
16232                         return 0; /* found */
16233                 }
16234         }
16235
16236         RTE_LOG(INFO, USER1, "%s not supported\n", flag_name);
16237         return TEST_SKIPPED;
16238 }
16239
16240 static int
16241 test_cryptodev_qat(void)
16242 {
16243         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
16244 }
16245
16246 static int
16247 test_cryptodev_virtio(void)
16248 {
16249         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
16250 }
16251
16252 static int
16253 test_cryptodev_aesni_mb(void)
16254 {
16255         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16256 }
16257
16258 static int
16259 test_cryptodev_cpu_aesni_mb(void)
16260 {
16261         int32_t rc;
16262         enum rte_security_session_action_type at = gbl_action_type;
16263         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16264         rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
16265         gbl_action_type = at;
16266         return rc;
16267 }
16268
16269 static int
16270 test_cryptodev_chacha_poly_mb(void)
16271 {
16272         int32_t rc;
16273         enum rte_security_session_action_type at = gbl_action_type;
16274         rc = run_cryptodev_testsuite(
16275                         RTE_STR(CRYPTODEV_NAME_CHACHA20_POLY1305_PMD));
16276         gbl_action_type = at;
16277         return rc;
16278 }
16279
16280 static int
16281 test_cryptodev_openssl(void)
16282 {
16283         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
16284 }
16285
16286 static int
16287 test_cryptodev_aesni_gcm(void)
16288 {
16289         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16290 }
16291
16292 static int
16293 test_cryptodev_cpu_aesni_gcm(void)
16294 {
16295         int32_t rc;
16296         enum rte_security_session_action_type at = gbl_action_type;
16297         gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
16298         rc  = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
16299         gbl_action_type = at;
16300         return rc;
16301 }
16302
16303 static int
16304 test_cryptodev_mlx5(void)
16305 {
16306         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD));
16307 }
16308
16309 static int
16310 test_cryptodev_null(void)
16311 {
16312         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
16313 }
16314
16315 static int
16316 test_cryptodev_sw_snow3g(void)
16317 {
16318         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
16319 }
16320
16321 static int
16322 test_cryptodev_sw_kasumi(void)
16323 {
16324         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
16325 }
16326
16327 static int
16328 test_cryptodev_sw_zuc(void)
16329 {
16330         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
16331 }
16332
16333 static int
16334 test_cryptodev_armv8(void)
16335 {
16336         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
16337 }
16338
16339 static int
16340 test_cryptodev_mrvl(void)
16341 {
16342         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
16343 }
16344
16345 #ifdef RTE_CRYPTO_SCHEDULER
16346
16347 static int
16348 test_cryptodev_scheduler(void)
16349 {
16350         uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0;
16351         const enum blockcipher_test_type blk_suites[] = {
16352                 BLKCIPHER_AES_CHAIN_TYPE,
16353                 BLKCIPHER_AES_CIPHERONLY_TYPE,
16354                 BLKCIPHER_AUTHONLY_TYPE
16355         };
16356         static struct unit_test_suite scheduler_multicore = {
16357                 .suite_name = "Scheduler Multicore Unit Test Suite",
16358                 .setup = scheduler_multicore_testsuite_setup,
16359                 .teardown = scheduler_mode_testsuite_teardown,
16360                 .unit_test_cases = {TEST_CASES_END()}
16361         };
16362         static struct unit_test_suite scheduler_round_robin = {
16363                 .suite_name = "Scheduler Round Robin Unit Test Suite",
16364                 .setup = scheduler_roundrobin_testsuite_setup,
16365                 .teardown = scheduler_mode_testsuite_teardown,
16366                 .unit_test_cases = {TEST_CASES_END()}
16367         };
16368         static struct unit_test_suite scheduler_failover = {
16369                 .suite_name = "Scheduler Failover Unit Test Suite",
16370                 .setup = scheduler_failover_testsuite_setup,
16371                 .teardown = scheduler_mode_testsuite_teardown,
16372                 .unit_test_cases = {TEST_CASES_END()}
16373         };
16374         static struct unit_test_suite scheduler_pkt_size_distr = {
16375                 .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
16376                 .setup = scheduler_pkt_size_distr_testsuite_setup,
16377                 .teardown = scheduler_mode_testsuite_teardown,
16378                 .unit_test_cases = {TEST_CASES_END()}
16379         };
16380         struct unit_test_suite *sched_mode_suites[] = {
16381                 &scheduler_multicore,
16382                 &scheduler_round_robin,
16383                 &scheduler_failover,
16384                 &scheduler_pkt_size_distr
16385         };
16386         static struct unit_test_suite scheduler_config = {
16387                 .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
16388                 .unit_test_cases = {
16389                         TEST_CASE(test_scheduler_attach_worker_op),
16390                         TEST_CASE(test_scheduler_mode_multicore_op),
16391                         TEST_CASE(test_scheduler_mode_roundrobin_op),
16392                         TEST_CASE(test_scheduler_mode_failover_op),
16393                         TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
16394                         TEST_CASE(test_scheduler_detach_worker_op),
16395
16396                         TEST_CASES_END() /**< NULL terminate array */
16397                 }
16398         };
16399         struct unit_test_suite *static_suites[] = {
16400                 &scheduler_config,
16401                 &end_testsuite
16402         };
16403         static struct unit_test_suite ts = {
16404                 .suite_name = "Scheduler Unit Test Suite",
16405                 .setup = scheduler_testsuite_setup,
16406                 .teardown = testsuite_teardown,
16407                 .unit_test_cases = {TEST_CASES_END()}
16408         };
16409
16410         gbl_driver_id = rte_cryptodev_driver_id_get(
16411                         RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
16412
16413         if (gbl_driver_id == -1) {
16414                 RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n");
16415                 return TEST_SKIPPED;
16416         }
16417
16418         if (rte_cryptodev_driver_id_get(
16419                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
16420                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
16421                 return TEST_SKIPPED;
16422         }
16423
16424         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16425                 uint8_t blk_i = 0;
16426                 sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof
16427                                 (struct unit_test_suite *) *
16428                                 (RTE_DIM(blk_suites) + 1));
16429                 ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]),
16430                                 blk_suites, RTE_DIM(blk_suites));
16431                 sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_testsuite;
16432         }
16433
16434         ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
16435                         (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
16436         ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
16437                         RTE_DIM(sched_mode_suites));
16438         ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
16439         ret = unit_test_suite_runner(&ts);
16440
16441         for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) {
16442                 FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx,
16443                                 (*sched_mode_suites[sched_i]),
16444                                 RTE_DIM(blk_suites));
16445                 free(sched_mode_suites[sched_i]->unit_test_suites);
16446         }
16447         free(ts.unit_test_suites);
16448         return ret;
16449 }
16450
16451 REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
16452
16453 #endif
16454
16455 static int
16456 test_cryptodev_dpaa2_sec(void)
16457 {
16458         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
16459 }
16460
16461 static int
16462 test_cryptodev_dpaa_sec(void)
16463 {
16464         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
16465 }
16466
16467 static int
16468 test_cryptodev_ccp(void)
16469 {
16470         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
16471 }
16472
16473 static int
16474 test_cryptodev_octeontx(void)
16475 {
16476         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
16477 }
16478
16479 static int
16480 test_cryptodev_caam_jr(void)
16481 {
16482         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
16483 }
16484
16485 static int
16486 test_cryptodev_nitrox(void)
16487 {
16488         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
16489 }
16490
16491 static int
16492 test_cryptodev_bcmfs(void)
16493 {
16494         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
16495 }
16496
16497 static int
16498 test_cryptodev_qat_raw_api(void)
16499 {
16500         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
16501         int ret;
16502
16503         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16504                         "RAW API");
16505         if (ret)
16506                 return ret;
16507
16508         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16509         ret = run_cryptodev_testsuite(pmd_name);
16510         global_api_test_type = CRYPTODEV_API_TEST;
16511
16512         return ret;
16513 }
16514
16515 static int
16516 test_cryptodev_cn9k(void)
16517 {
16518         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD));
16519 }
16520
16521 static int
16522 test_cryptodev_cn10k(void)
16523 {
16524         return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
16525 }
16526
16527 static int
16528 test_cryptodev_dpaa2_sec_raw_api(void)
16529 {
16530         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16531         int ret;
16532
16533         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16534                         "RAW API");
16535         if (ret)
16536                 return ret;
16537
16538         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16539         ret = run_cryptodev_testsuite(pmd_name);
16540         global_api_test_type = CRYPTODEV_API_TEST;
16541
16542         return ret;
16543 }
16544
16545 static int
16546 test_cryptodev_dpaa_sec_raw_api(void)
16547 {
16548         static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
16549         int ret;
16550
16551         ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP,
16552                         "RAW API");
16553         if (ret)
16554                 return ret;
16555
16556         global_api_test_type = CRYPTODEV_RAW_API_TEST;
16557         ret = run_cryptodev_testsuite(pmd_name);
16558         global_api_test_type = CRYPTODEV_API_TEST;
16559
16560         return ret;
16561 }
16562
16563 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest,
16564                 test_cryptodev_dpaa2_sec_raw_api);
16565 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest,
16566                 test_cryptodev_dpaa_sec_raw_api);
16567 REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest,
16568                 test_cryptodev_qat_raw_api);
16569 REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat);
16570 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb);
16571 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest,
16572         test_cryptodev_cpu_aesni_mb);
16573 REGISTER_TEST_COMMAND(cryptodev_chacha_poly_mb_autotest,
16574         test_cryptodev_chacha_poly_mb);
16575 REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl);
16576 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm);
16577 REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest,
16578         test_cryptodev_cpu_aesni_gcm);
16579 REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5);
16580 REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null);
16581 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g);
16582 REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi);
16583 REGISTER_TEST_COMMAND(cryptodev_sw_zuc_autotest, test_cryptodev_sw_zuc);
16584 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_autotest, test_cryptodev_armv8);
16585 REGISTER_TEST_COMMAND(cryptodev_sw_mvsam_autotest, test_cryptodev_mrvl);
16586 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_autotest, test_cryptodev_dpaa2_sec);
16587 REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_autotest, test_cryptodev_dpaa_sec);
16588 REGISTER_TEST_COMMAND(cryptodev_ccp_autotest, test_cryptodev_ccp);
16589 REGISTER_TEST_COMMAND(cryptodev_virtio_autotest, test_cryptodev_virtio);
16590 REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx);
16591 REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr);
16592 REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox);
16593 REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs);
16594 REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k);
16595 REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);
16596
16597 #endif /* !RTE_EXEC_ENV_WINDOWS */